Você sabe como executar comandos para gerir processos no Linux? Essa é uma dificuldade natural de todos os usuários e programadores iniciantes ou mesmo intermediários do universo Linux.
Saber quais comandos devem ser usados para cada função é uma responsabilidade de quem usa o Linux como seu ambiente e ferramenta de trabalho.
Além disso, é sua responsabilidade também analisar quais processos estão sendo executados e balanceá-los, a fim de que o processador ou o Kernel do Linux não fique sobrecarregado.
Todos esses pontos não são conhecimentos adquiridos “da noite para o dia”, mas são aprendidos com o tempo, através do estudo acerca de quais são os melhores comandos do Linux.
Trabalhar com processos em segundo plano é ideal para aquelas tarefas que são executadas em lote. Saiba como fazer isso no Linux
Vamos conhecer os comandos que tratam de escalonar os processos em segundo plano:
Comando jobs
Uso:
$ jobs [opções]
O comando jobs lista os processos que estão em execução em segundo
plano. Se um número da tarefa é fornecido o comando retornará as informações
pertinentes somente à tarefa em questão.
O número da tarefa é fornecido quando o processo é colocado em
segundo plano.
As opções mais frequentes são:
-l Lista o PID dos processos em segundo plano.
Comando bg
Uso:
$ bg [número_da_tarefa]
O comando bg coloca em segundo plano um processo em execução.
Colocar o sinal “&” depois da chamada do comando faz o mesmo efeito.
Se um comando já estiver em
execução em primeiro plano, isto é, ligado a um terminal, nós podemos
interromper temporariamente sua execução com o sinal TSTP (18) pressionando as
teclas ctrl-z e acionando logo depois do comando bg.
Comando fg
Uso:
$ fg [número_da_tarefa]
O comando fg faz exatamente o oposto do comando bg, colocando a
tarefa em primeiro plano e ligada a um terminal.
Comando nohup
Uso:
$ nohup [comando]
O utilitário nohup executa o comando
especificado sem atrelá-lo a nenhum terminal, de forma imune a travamentos,
quedas de conexão e desconexões propositais.
Aprenda muito mais sobre Linux em nosso curso online. Você pode fazer a matrícula aqui com trial de 7 dias grátis. Se você já tem uma conta, pode acessar aqui.
É possível modificar a prioridade de execução dos processos no Linux, através dos comandos nice e renice. Estes comandos são extremamente úteis em ambientes multiusuário
Imagine um servidor com muitos usuários logados e cada um executando algo. Neste tipo de ambiente, é preciso dar mais ou menos fatias de processamento aos diversos programas dos usuários, para manter um ambiente estável e organizado.
Comando nice
Uso:
$ nice [-n ajuste_de_prioridade] [comando]
O comando nice ajusta o tempo disponível de CPU de um processo para
mais ou para menos prioridade.
No inglês a palavra “nice” quer dizer “legal”. Se o ajuste de
prioridade para um processo for um número positivo, quer dizer que ele está
sendo mais legal com os outros programas diminuindo a sua prioridade.
Se o ajuste for um número negativo, quer dizer que o programa está
sendo menos legal, aumentando a sua prioridade de execução e sobrando menos
tempo de CPU para os outros programas.
O ajuste de prioridade possível vai do –20 (mais prioridade / menos legal) até o 19 (mais legal, menos prioridade).
Se não for passado nenhum valor de ajuste, o comando nice ajustará
a prioridade para +10, diminuindo o tempo de execução do processo.
$ nice updatedb &
Neste exemplo o comando updatedb tem menos prioridade de execução.
$ nice –n –10 folha_pagamento
Neste exemplo o comando
folha_pagamento será executado com mais prioridade.
O comando renice ajusta a prioridade de execução de processos que já estão rodando. Por padrão, o comando renice recebe como parâmetro o PID de um determinado processo.
O ajuste de prioridade é um número inteiro que vai do –20 (maior prioridade) até o +20 (executar qualquer coisa antes deste processo).
As opções mais usuais são:
-p: Recebe um PID para alterar sua prioridade.
-u: Recebe um nome de usuário para alterar a prioridade de todos os processos deste usuário em execução.
-g: Recebe um nome de um grupo para alterar a prioridade de todos os processos pertencentes a este grupo.
Exemplo:
# renice -1 987 -u daemon root -p 32
Neste exemplo, o processo de número PID 987, PID 32 e todos os processos de que os usuários daemon e root são donos vão ter mais prioridade.
Veja como trabalhar com processos no Linux e colocar processos em segundo plano.
Aprenda muito mais sobre Linux em nosso curso online. Você pode efetuar a matrícula aqui. Se você já tem uma conta, ou quer criar uma, basta entrar ou criar seu usuário aqui.
Veja quais são os atributos dos processos (programas) no Linux
É importante que você entenda que cada programa é pelo menos um
processo e que cada processo possui alguns atributos, tais como:
Process ID (PID) ou identificação do processo: Cada processo possui um número de identificação único. O primeiro processo init sempre terá o PID 1 e para o restante dos processos este número é incrementado à medida que novos processos são executados;
User ID e Group ID (ID do usuário e ID do grupo): Os processos precisam ser executados com os privilégios de uma conta de usuário e do grupo associado a eles. Isto é importante porque assim o sistema pode determinar e gerenciar o acesso aos recursos;
Processo Pai: No Linux nenhum processo é executado de forma independente dos outros. Todos os processos no sistema, com exceção do init, possuem um processo pai, que é responsável pela sua execução. O atributo ParentID grava o PID do processo pai. Caso o processo pai termine sua execução antes do processo filho, o processo filho é “apadrinhado” pelo init, ganhando o Parent ID igual a 1;
Variáveis de ambiente: Cada processo herda do processo pai algumas variáveis de ambiente que simplesmente guardam alguns valores que podem ou não ser importantes para o processo em execução. É possível que durante sua execução um processo altere, incremente ou apague uma variável de ambiente. Um processo filho pode herdar as variáveis de um processo pai. Mas um processo pai não consegue acessar as variáveis criadas ou alteradas por seus filhos.
Diretório de trabalho: Os processos também são associados a um diretório de trabalho, onde podem fazer a leitura e a escrita do disco;
Temporizadores: O Kernel mantém registros da hora em que os processos são criados bem como o tempo de CPU que eles consomem durante a sua execução.
Em um ambiente multiprogramado com apenas um processador, cada processo é executado aos poucos de cada vez, de forma intercalada.
O sistema operacional aloca a CPU um pouco para cada processo. Um processo após receber o controle do processador só o perderá quando ocorrer uma interrupção ou quando requerer algum serviço do sistema operacional.
Estas interrupções são transparentes aos processos, pois apenas interrompem temporariamente sua execução, que depois continuará a ser executada como se nada tivesse acontecido.
Ao requerer um serviço do sistema operacional, o processo é bloqueado até que o serviço requerido ao sistema operacional seja satisfeito.
Aprenda muito mais sobre Linux em nosso curso online. Você pode fazer a matrícula aqui com trial de 7 dias grátis. Se você já tem uma conta, pode acessar aqui.
