Como visualizar e executar processos em segundo plano do Linux

A execução de processos é vital em qualquer sistema operacional utilizado, pois garantem que tanto as aplicações quanto os demais elementos do sistema operacional possam atuar de forma correta tanto na compatibilidade quanto na execução de suas funções.

Cada sistema operacional pode lidar com processos de forma diferente, mas no caso do Linux, como regra, os processos são associados a um terminal. Isso significa que deve ser aberto para que o processo funcione normalmente, mas essa ação pode levar a situações como:

• O terminal aberto pode conter muitos dados de saída ou mensagens de erro / diagnóstico que tornam difícil não apenas ler os dados, mas também gerenciá-los.

• Se fecharmos o terminal, o processo em conjunto com seus processos secundários acabará afetando diretamente a tarefa a ser realizada.

Neste tipo de cenário, é imprescindível a execução dos processos necessários em segundo plano, processo em segundo plano é o processo que será executado de forma oculta e para o seu funcionamento não é necessária a intervenção do usuário, desta forma, embora o terminal é fechado principal, o processo continuará executando sua tarefa. Os processos em segundo plano se aplicam às tarefas que podem levar tempo, como scripts, baixar arquivos e outros, em que não podemos esperar que a ação seja concluída sem fazer nada.

No Linux, podemos executar processos em primeiro ou segundo plano. Um programa em primeiro plano quando executado no terminal, não poderemos executar nenhum outro comando até que o processo termine, mas pode ser feito em segundo ou segundo plano.

Um programa executado em segundo plano depois de iniciado não usa o terminal desde o momento em que foi executado até o fim. Para executar um software ou comando em segundo plano a partir do terminal, adicionamos Se adicionarmos um "e" comercial (&) no final do comando ou script que queremos executar, ele será executado em segundo plano pelo sistema operacional. Exemplo:

 nano e 

O Solvetic explicará como podemos ver e executar processos em segundo plano no Linux.

1. Veja a lista de processos com o comando ps no Linux

Com o comando ps, podemos saber o estado de um processo Ps é o estado do processo ou estado do processo. O comando ps não lista os processos e especifica algumas colunas PID, TTY, TIME e CMD.

PID (Número do Processo)Cada processo recebe um número de identificação exclusivo, que é atribuído pelo kernel Linux.

TTYé o terminal associado ao processo, também pode ser outro dispositivo de entrada.

TEMPOA hora em que o processo está em execução.

CMDÉ o nome do comando que está sendo executado, bash é o processo do shell.

Por exemplo, com o comando ps -A ele nos mostrará todos os processos em execução.

2. Inicie um processo ou comando em segundo plano no Linux usando bg no Linux

O comando bg foi desenvolvido como um comando de controle de tarefas que retoma as tarefas suspensas, mas as executa em segundo plano.

Passo 1
A sintaxe básica deste comando é a seguinte:

 bg [trabalho] 

Passo 2
Caso um processo já esteja em execução, devemos pressionar as seguintes teclas para interrompê-lo e, em seguida, inserir o comando bg para continuar sua execução em segundo plano como um trabalho. Para este exemplo, usaremos as seguintes linhas:

Ctrl + Z

 tar -czf home.tar.gz. (processo em execução que será interrompido com Ctrl + Z) bg (execução do comando em segundo plano) jobs (visualização dos trabalhos realizados)

etapa 3
Podemos ver que o processo ainda está em execução, mas agora em segundo plano. Também será possível executar um processo diretamente em segundo plano, inserindo o E comercial no final dele:

 tar -czf home.tar.gz. & Empregos 

3. Salve os processos do Linux em execução após sair do terminal no Linux

Este é um ponto essencial, pois, como já mencionamos, no modo normal quando o terminal estiver fechado todos os processos ativos serão encerrados, de modo que é possível permitir que continuem em execução mesmo com o terminal fechado.

Para isso, podemos usar o comando disown que será usado após um processo ter sido iniciado e colocado em segundo plano, o comando disown é um shell job cuja missão é eliminar os jobs da lista ativa do Shell ativo.

Passo 1
Com a execução do disown, ao fecharmos o terminal, o job não irá travar ou enviar um SIGHUP para qualquer job filho. Sua sintaxe básica é:

 rejeitar ID do trabalho 

Passo 2
Para o seu funcionamento iremos executar o seguinte:

 Sudo rsync Templates / * / var / www / html / files / & (comando para executar) jobs (jobs ativos) rejeitar -h% 1 (ordem para não fechar o processo ou comando) jobs (display of jobs)

ObservaçãoNo caso de executar mais de um processo ou comando, podemos verificar que cada um deles recebe um ID de identificação, este deve ser informado com disown para especificar qual processo continuará rodando.

etapa 3
As opções para usar com rejeição são:

-paraRemove todos os trabalhos se jobID não for fornecido.

-hMarca cada ID de trabalho para que SIGHUP não seja enviado ao trabalho se o shell receber um SIGHUP.

-rLimpa apenas trabalhos em execução.

4. Salve os processos do Linux em execução após sair do terminal no Linux

A tarefa básica do comando nohup é evitar que o comando seja cancelado automaticamente ao fazer logout ou sair do shell. Ao usar o comando nohup (no hangup), o sinal hangup (HUP), que é enviado a um processo para informá-lo de que o usuário efetuou logout, é interceptado pelo nohup para permitir que o processo continue rodando em segundos.

Passo 1
A sintaxe de uso é a seguinte:

 comando nohup [argumento-comando …] 

Passo 2
Para este caso, usaremos o seguinte exemplo. Se a entrada padrão for um terminal, nohup o redireciona de / dev / null. Portanto, a entrada do terminal não é possível ao executar um comando com nohup. Caso a saída padrão seja um terminal, a saída do comando é adicionada ao arquivo nohup.out ou $ HOME / nohup.out. Se o erro padrão for um terminal, ele será redirecionado para a saída padrão. Para salvar a saída em um arquivo, devemos usar "comando nohup> arquivo".

 nohup tar -czf iso.tar.gz Templates / * & jobs

5. Desvincular um processo Linux no terminal

Passo 1
Se o objetivo é separar completamente um processo do terminal, devemos usar a seguinte sintaxe:

 app / dev / null & 

Passo 2
Por exemplo:

 firefox / dev / null & 

6. Use processos em segundo plano com Screen no Linux

No caso de utilizar um comando em segundo plano, com as opções nohup e &), ele será executado mesmo após o encerramento da sessão, o problema é que, ao nos reconectarmos à mesma sessão novamente, não veremos o trabalho ativo em o fundo, para corrigir isso existe o comando de tela.

screen é um gerenciador de janelas em tela cheia que gerencia um terminal físico entre vários processos, normalmente os shells sendo interativos. Cada terminal virtual oferece as funções de um terminal DEC VT100 e, além disso, várias funções de controle dos padrões ISO 6429 (ECMA 48, ANSI X3.64) e ISO 2022 que o tornam extremamente dinâmico.

Quando executamos a tela, uma única janela é criada com um shell ou o comando especificado e então contornada para poder usar o programa normalmente.

Passo 1
Para instalar a tela no Linux, vamos executar o seguinte. Lá, inserimos a letra S para confirmar o download e a instalação.

 sudo apt tela de instalação

Passo 2
Uma vez instalado, executamos o comando "tela" e veremos o seguinte:

etapa 3
Lá, pressionamos a tecla Enter para ser redirecionado para a nova janela onde executamos o processo ou comando para usar em segundo plano:

 sudo tar czf temp.tar.gz / tmp & 

Passo 4
Poderemos visualizar as janelas ativas usando. Para sair da sessão de tela, podemos usar as teclas

Ctrl + a + d

Ctrl + Alt + d

 tela -ls 

7. Pare ou elimine um processo suspenso ou em segundo plano no Linux

Para esta ação, que consiste em encerrar a execução do processo em background, podemos utilizar o comando "kill" e em vez do PID podemos especificar o identificador do job, por exemplo:

 jobs (lista de jobs atuais) kill% 2 (kill ou encerrar processo é identificado como 2)

8. Pare um processo ou coloque-o em segundo plano

Alguns programas demoram muito para terminar e, nesse ínterim, não fazem nada de importante. Compilar programas é uma dessas tarefas, assim como compactar um arquivo grande. Não faz sentido parar de usar o computador enquanto esses processos terminam e consomem recursos. Nestes casos, é melhor executá-los em segundo plano, para deixar o computador em condições de executar outro programa.

Os processos podem ser suspensos. Um processo suspenso é aquele que não está em execução, mas está temporariamente interrompido. Depois de suspender uma tarefa, você pode instruir a tarefa para continuar, em primeiro plano ou segundo, conforme necessário. Retomar uma tarefa suspensa não altera o status da tarefa, pois ela continuará sendo executada exatamente de onde parou.

Passo 1
Para interromper um processo é usada a seguinte combinação, ao pressionar esta combinação o processo morre e todos os recursos são liberados.

Ctrl + C

Passo 2
Vamos tentar enviar um comando de repetição para o plano de fundo. O comando yes é usado para testar o script que requer muitas confirmações. O que ele faz é repetir "e" com tudo o que está escrito na frente dele infinitamente até que o script seja interrompido ou o usuário o interrompa:

• Se digitarmos "sim" no terminal, veremos uma lista interminável de "e".

• Se digitarmos sim, olá no terminal e veremos uma lista interminável de olá

etapa 3
Para excluir um arquivo sem pressionar nenhuma tecla quando ele pede confirmação, podemos usar

 sim | rm -i * .txt 

Passo 4
Para enviar um processo para o segundo plano, nós o chamamos da linha de comando seguido por & criamos infinitos dispositivos nulos

 sim> / dev / null & 

Etapa 5
Isso nos mostrará o número da tarefa e o pid [1] 4106. Se usarmos agora o comando jobs veremos

 [1] + Executando sim> / dev / null &

Etapa 6
para trazê-lo para o primeiro plano, escrevemos fg 1 e para matar o processo, mate 4106 que é o pid.

 Fg 1 Kill 4106

Com qualquer uma das opções indicadas, será possível gerenciar os processos de background no Linux de uma forma muito mais central e assim permitir que as tarefas necessárias sejam executadas mesmo quando a sessão é encerrada.