Gerenciamento de processos de fundo bash

Há muitas vezes em que um desenvolvedor ou usuário bash desejará executar um processo em segundo plano, seja da linha de comando ou de dentro de um script de bash, e depois lidar com o mesmo processo novamente. Existem várias ferramentas de linha de comando que permitem fazer isso. Ser capaz de iniciar, gerenciar e destruir processos de fundo é um requisito para muitas tarefas de nível mais avançado, especialmente nas áreas de script avançado e controle de processo.

Neste tutorial, você aprenderá:

• Como iniciar, lidar e/ou gerenciar e destruir processos de fundo
• Quais ferramentas de linha de comando estão disponíveis para ajudá -lo com o gerenciamento de processos Bash
• Exemplos destacando o uso de processos de fundo na linha de comando Bash

Requisitos de software e convenções usadas

Exemplo 1: Iniciando um processo em segundo plano e trazendo -o de volta ao primeiro plano

$ Sleep 1000 e [1] 25867 $ FG Sleep 1000 

Aqui começamos um processo de sono de 1000 segundos em segundo plano. Se quisermos colocar um processo em segundo plano, podemos usar o AMPERSAND (&) Assinar por trás de qualquer comando. Isso colocará o processo em segundo plano e reporta de volta o PID (ID do processo, um número de identificador que identifica qualquer processo em execução em uma máquina Linux). Neste exemplo, o PID é 25867. Observe que o processo continua funcionando quando é colocado em segundo plano, o que nos dá o melhor dos dois mundos; O processo está executando e recebemos nossa linha de comando de volta nesse meio tempo! Ótimo.

Em seguida, colocamos o processo de volta em primeiro plano (como se nunca houvesse uma instrução de fundo) usando o FG (eu.e. em primeiro plano) comando. O resultado é que vemos qual processo está sendo colocado em primeiro plano (eu.e. sono 1000) e nosso prompt de comando não retorna quando colocamos o sono de volta em primeiro plano e o prompt de comando só retornará quando o sono de 1000 segundos for feito.

Digamos que colocamos o sono 1000 em segundo plano, fez outro trabalho por 500 segundos e depois executado FG… Quanto tempo o sono ainda funcionaria? Se você adivinhe (ou soube) 500 segundos, então você está correto. Os primeiros 500 segundos foram gastos em execução como um processo de fundo, e o segundo 500 será como um processo de primeiro plano.

Observe também que, se você encerrar o shell, seu comando será encerrado - esteja ele está sendo executado em segundo plano ou em primeiro plano (a menos que você o deserdasse, mais sobre isso no próximo exemplo).

Exemplo 2: Relando um processo

$ Sleep 1000 & [1] 26090 $ DOLED %1 $ $ 

Aqui começamos outro sono de 1000 segundos e fomos informados do PID do processo de fundo como antes. Em seguida, executamos Dened %1, referindo -se ao primeiro processo de segundo plano (como também indicado pelo [1] Antes do PID!), e instruindo o Bash a rejeitar (desassociar) esse processo do shell atual. Não é que seja desassociado do usuário atual (e por exemplo ps -ef | sono grep | grep -v grep realmente ainda mostrará seu UserID), mas sim da sessão de shell atual. Olhar:

$ Sleep 1000 & [1] 26214 $ DONOWN %1 $ PS -EF | sono grep | Grep -v Grep Roel 26214 26120 0 13:13 pts/3 00:00:00 Sono 1000 $ Sair 

Então, abrindo uma nova concha e reexecionando o ps Podemos ver que o comando ainda está lá e agora está anexado ao PPID (pai PID) 1 em vez de 26120 Como pai PID:

$ ps -ef | sono grep | Grep -v Grep Roel 26214 1 0 19:48 ? 00:00:00 Durma 1000 

É como se o shell ainda estivesse em execução (observe o 26214 Pid ainda sendo ativo/associado à corrida dormir), no entanto, a parte da linha de comando ativa se foi!

Ótimo, então isso nos dá uma maneira de desassociar processos do shell atual e, assim, garante que eles continuem correndo quando nossa sessão de shell estiver fechada.

Exemplo 3: Colocando um comando em segundo plano

$ sono 1000 ^z [1]+ Sono parado de 1000 $ BG %1 [1]+ Sono 1000 e $ 

Aqui começamos um sono 1000 em primeiro plano (não & foi usado), e o interrompido esse processo com o atalho do teclado Ctrl+z. Observe que enquanto a saída diz ^Z (e ^ é um símbolo para indicar Ctrl), o Z é realmente um minúsculo z, Então você não precisa usar MUDANÇA, apenas Ctrl+z.

Observe que o processo realmente parou, ele não continuou correndo. Agora colocamos o processo em segundo plano e paramos. Para deixar esse processo continuar em execução agora, temos duas opções; FG %1 - eu.e. Coloque o processo indicado por [1] de volta ao primeiro plano e continue correndo normalmente, ou BG %1 que retomará o processo, mas em segundo plano. No exemplo, podemos ver o último, e nosso prompt de comando retorna conforme o esperado.

Observe que o acima pode ser ligeiramente aumentado com Denem, Combinando uma maneira frequentemente usada de lidar com um processo ao usar um servidor remoto. Digamos que você esteja conectado via SSH a um servidor remoto e iniciou um grande trabalho, por exemplo, uma geração de backup ou relatório. Agora você gostaria de deixar seu escritório durante o dia, mas não tem certeza se sua conexão SSH permanecerá ao vivo a noite toda, e mesmo se o seu computador não hibernará ou similar. Qualquer uma dessas ações pode comprometer o trabalho em execução!

Nesse caso, você pode fazer o seguinte;

$ sono 1000 ^z [1]+ Sono parado de 1000 $ BG %1 [1]+ Sono 1000 e $ DONOWN %1 $ 

E feliz e com segurança se afasta do seu computador (depois de travá -lo;), pois você pode ter certeza de que - mesmo que sua conexão SSH falhe, ou o seu computador hiberna, ou a limpeza da senhora nocautear o cabo de alimentação - que seu trabalho permanecerá correndo. Como o processo foi renegado/desassociado da sessão atual, ele continuará sendo executado mesmo que a sessão atual seja de alguma forma encerrada.

Uma pequena ressalva é que você não pode usar FG De manhã para trazer o trabalho de volta ao primeiro plano, mesmo que sua conexão e shell ssh nunca tivessem terminado/falhado:

$ FG BASH: FG: atual: não é esse trabalho $ FG %1 BASH: FG: %1: Nenhum trabalho 

Quando é renegado, é desassociado e se foi! O trabalho ainda estará em segundo plano, e você pode até matá -lo usando seu pid (como pode ser observado de ps -ef | grep your_process_name | grep -v grep.

Exemplo 4: Múltiplos processos de fundo e processos de encerramento

Primeiro, começamos dois processos em segundo plano usando nosso confiável sono 1000 exemplo:

$ Sleep 1000 & [1] 27158 $ Sleep 1000 & [2] 27159 

Podemos ver aqui que dois processos de fundo ([1] e [2], com pid 27158 e 27159 respectivamente) foram iniciados. Em seguida, matamos o primeiro processo:

$ kill %1 $ [1]- sono terminado 1000 $ 

Isso foi direto/fácil, certo? Uma pergunta que se pode fazer é por que as informações encerradas não são exibidas imediatamente (uma inspeção extra é necessária como você pode ver) e o motivo é que o processo não foi encerrado antes que a linha de comando fosse retornada. Como parte do trabalho que é feito sempre antes de uma nova linha de comando ser mostrada é relatar em vários status, incluindo o status do processo de fundo, se necessário. Assim, quando Enter foi pressionado novamente (indicado pelo vazio $ Linha, um relatório do processo terminado é mostrado.

Exemplo 5: um feito antes do outro

Vamos iniciar novamente dois processos, mas desta vez o segundo processo dormirá apenas por 3 segundos:

$ Sleep 1000 & [1] 27406 $ Sleep 3 & [2] 27407 $ 

Após cerca de 5 segundos, pressionando Enter, veremos:

$ [2]+ Sono feito 3 

O que vai acontecer agora se usarmos FG neste caso sem o original [1] especificador?

$ fg sono 1000 ^z [1]+ Sono parado de 1000 $ 

O primeiro processo continuará! Este também é o caso se o procedimento reverso foi usado:

$ Sleep 10 & [1] 27346 $ Sleep 1000 & [2] 27347 $ [1]- Sono feito 10 $ FG Sleep 1000 ^z [2]+ Sono parado 1000 

O FG O comando sempre assumirá o último comando que foi colocado em segundo plano (e que ainda não foi concluído) e o colocará em primeiro plano novamente.

Conclusão

Neste artigo, analisamos vários comandos, incluindo bg, FG e o bash bash idiom ampers e & que pode ser colocado após qualquer comando para colocar esse comando em segundo plano. Nós também exploramos o usuário do matar comando e analisou como abordar vários processos de segundo plano usando o % Bash idioma com um número de processo de fundo correspondente como %1 para [1] etc.

Se você deseja aprender mais sobre o Bash em geral, dê uma olhada nas séries úteis das dicas e truques da linha de comando Bash.

Aproveite suas novas habilidades de bash encontradas e, se você fizer algo legal com processos de fundo, deixe -nos um comentário abaixo!

Tutoriais do Linux relacionados:

• Uma introdução à automação, ferramentas e técnicas do Linux
• Mastering Bash Script Loops
• Loops aninhados em scripts de basquete
• Coisas para instalar no Ubuntu 20.04
• Multi-thread Bash Script e Gerenciamento de Processos no…
• Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
• Manipulando a entrada do usuário em scripts bash
• Sistema Linux Hung? Como escapar para a linha de comando e…
• Tutorial de depuração do GDB para iniciantes
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux