Gerenciamento de Tarefas Linux

Introdução

Neste laboratório, você aprenderá os fundamentos do gerenciamento de tarefas (job management) no Linux. O gerenciamento de tarefas é uma habilidade essencial para usuários Linux, permitindo que você execute múltiplos processos simultaneamente e controle sua execução. Ao dominar o gerenciamento de tarefas, você pode executar comandos eficientemente em segundo plano (background), alternar entre tarefas em primeiro plano (foreground) e em segundo plano, e manter o controle sobre todos os processos em execução.

Ao longo deste laboratório, você aprenderá:

• Como iniciar processos em segundo plano
• Como visualizar e gerenciar tarefas em execução
• Como trazer tarefas em segundo plano para o primeiro plano
• Como suspender tarefas em execução e retomá-las posteriormente
• Como terminar tarefas quando elas não são mais necessárias

Essas habilidades são particularmente úteis ao trabalhar com tarefas de longa duração que não exigem interação constante, permitindo que você continue trabalhando em outras tarefas enquanto os processos são executados em segundo plano.

Iniciando e Gerenciando Tarefas em Segundo Plano

Nesta etapa, você aprenderá como iniciar um processo em segundo plano usando o símbolo ampersand (&) e como gerenciá-lo usando o comando jobs.

O que é uma Tarefa em Segundo Plano?

No Linux, uma tarefa (job) é um processo que o shell gerencia. Por padrão, quando você executa um comando em um terminal, ele é executado em primeiro plano (foreground) - o que significa que seu terminal fica ocupado até que o comando seja concluído. No entanto, adicionando o símbolo & no final de um comando, você pode executá-lo em segundo plano, liberando seu terminal para outras tarefas.

Criando um Processo em Segundo Plano

Vamos criar um script simples que será executado continuamente em segundo plano. Isso simulará uma tarefa de longa duração que você pode querer executar enquanto continua trabalhando em outras coisas.

Primeiro, navegue até o diretório do projeto, se você ainda não estiver lá:

cd ~/project

Agora, crie um script chamado background_task.sh usando o editor de texto nano:

nano ~/project/background_task.sh

Dentro do editor, adicione o seguinte conteúdo:

#!/bin/bash
## A simple script that simulates a long-running task
count=0
while true; do
  count=$((count + 1))
  echo "Task running: iteration $count"
  sleep 5
done

Este script será executado indefinidamente, imprimindo uma mensagem a cada 5 segundos.

Pressione Ctrl+O seguido por Enter para salvar o arquivo, e então Ctrl+X para sair do nano.

Em seguida, torne o script executável:

chmod +x ~/project/background_task.sh

Agora, execute o script em segundo plano adicionando o símbolo & no final do comando:

~/project/background_task.sh &

Você deve ver uma saída semelhante a:

[1] 1234

O número entre colchetes [1] é o número da tarefa (job number), e o número após ele é o ID do processo (PID). Esses números podem ser diferentes no seu sistema.

Verificando as Tarefas em Execução

Para visualizar todas as tarefas em segundo plano atualmente em execução, use o comando jobs:

jobs

Você deve ver uma saída semelhante a:

[1]  + running    ~/project/background_task.sh

Isso confirma que seu script está sendo executado em segundo plano.

Para obter informações mais detalhadas sobre a tarefa, incluindo seu PID, use:

jobs -l

A saída deve mostrar o número da tarefa, o PID e o status:

[1]  + 1234 running    ~/project/background_task.sh

Seu terminal permanece livre para você executar outros comandos enquanto o script continua a ser executado em segundo plano. A saída do script ainda é enviada para o terminal, então você verá mensagens aparecendo periodicamente.

Trazendo Tarefas em Segundo Plano para o Primeiro Plano

Nesta etapa, você aprenderá como trazer uma tarefa em segundo plano para o primeiro plano usando o comando fg. Isso é útil quando você precisa interagir com um processo que está atualmente sendo executado em segundo plano.

O que é Trazer para o Primeiro Plano (Foregrounding)?

Trazer para o primeiro plano (foregrounding) refere-se ao processo de trazer uma tarefa em segundo plano para o primeiro plano, tornando-a o processo ativo em seu terminal. Quando uma tarefa está em primeiro plano, ela tem controle do seu terminal - você pode interagir com ela diretamente, mas não pode executar outros comandos até que ela seja concluída ou movida de volta para o segundo plano.

Usando o Comando fg

Certifique-se de que seu script background_task.sh ainda esteja em execução da etapa anterior. Você pode verificar isso com:

jobs

Você deve ver seu script listado como uma tarefa em execução.

Para trazer a tarefa para o primeiro plano, use o comando fg seguido pelo número da tarefa com um sinal de porcentagem:

fg %1

Se você tiver apenas uma tarefa em segundo plano, você pode simplesmente usar:

fg

Após executar o comando, o script será trazido para o primeiro plano, e você verá sua saída diretamente em seu terminal:

Task running: iteration X
Task running: iteration X+1
...

Você notará que o seu prompt de comando desaparece, e o script agora tem controle do seu terminal. Você não pode mais inserir outros comandos até que você termine o script ou o mova de volta para o segundo plano.

Parando a Tarefa em Primeiro Plano

Para parar a tarefa em primeiro plano e retornar ao prompt de comando, pressione Ctrl+C. Isso envia um sinal de interrupção para o processo, fazendo com que ele termine.

^C

O terminal agora deve exibir uma mensagem indicando que a tarefa foi terminada, e você deve ver seu prompt de comando novamente.

Para verificar se a tarefa não está mais em execução, execute:

jobs

Não deve haver saída, indicando que nenhuma tarefa em segundo plano está em execução.

Vamos iniciar nosso script em segundo plano novamente para a próxima etapa:

~/project/background_task.sh &

Você deve ver a confirmação de que a tarefa foi iniciada, com uma saída semelhante a:

[1] 1345

Lembre-se, o número da tarefa e o PID podem ser diferentes no seu sistema.

Suspender e Retomar Tarefas

Nesta etapa, você aprenderá como suspender uma tarefa em primeiro plano em execução e retomá-la, seja em primeiro plano ou em segundo plano. Isso é útil quando você precisa pausar temporariamente um processo sem terminá-lo.

Suspendendo uma Tarefa em Primeiro Plano

Primeiro, vamos trazer nossa tarefa em segundo plano para o primeiro plano:

fg %1

Você deve agora ver a saída do script em seu terminal. Para suspender esta tarefa em primeiro plano, pressione Ctrl+Z:

^Z

Você deve ver uma mensagem semelhante a:

[1]  + suspended  ~/project/background_task.sh

Isso indica que a tarefa foi suspensa. A tarefa ainda está carregada na memória, mas não está sendo executada - ela está essencialmente "pausada".

Para verificar se a tarefa está suspensa, execute:

jobs

Você deve ver uma saída semelhante a:

[1]  + suspended  ~/project/background_task.sh

Retomando uma Tarefa Suspensa em Segundo Plano

Você pode retomar uma tarefa suspensa em primeiro ou segundo plano. Para retomá-la em segundo plano, use o comando bg seguido pelo número da tarefa:

bg %1

Você deve ver uma mensagem confirmando que a tarefa foi retomada em segundo plano:

[1]  + continued  ~/project/background_task.sh

Verifique se a tarefa agora está sendo executada em segundo plano:

jobs

A saída deve mostrar que o status da tarefa mudou de "suspended" (suspenso) para "running" (executando):

[1]  + running    ~/project/background_task.sh

Retomando uma Tarefa Suspensa em Primeiro Plano

Vamos suspender a tarefa novamente. Primeiro, traga-a para o primeiro plano:

fg %1

Em seguida, pressione Ctrl+Z para suspendê-la:

^Z

Agora, em vez de usar bg para retomá-la em segundo plano, use fg para retomá-la em primeiro plano:

fg %1

A tarefa retomará a execução, e você verá sua saída em seu terminal novamente.

Vamos parar a tarefa pressionando Ctrl+C:

^C

Isso terminará a tarefa e retornará você ao prompt de comando.

Usando o Controle de Tarefas em Seu Fluxo de Trabalho

A capacidade de suspender, retomar em segundo plano, retomar em primeiro plano e terminar tarefas oferece um controle poderoso sobre seus processos. Este fluxo de trabalho é particularmente útil quando:

1. Você precisa verificar outra coisa enquanto um processo está em execução
2. Você precisa liberar temporariamente recursos do sistema
3. Você deseja executar vários processos interativamente sem abrir várias janelas de terminal

Para a próxima etapa, inicie a tarefa em segundo plano novamente:

~/project/background_task.sh &

Finalizando Tarefas em Segundo Plano

Nesta etapa, você aprenderá diferentes maneiras de terminar tarefas em segundo plano quando elas não forem mais necessárias. A terminação adequada de tarefas é importante para liberar recursos do sistema e manter o desempenho do sistema.

Identificando Tarefas para Terminação

Primeiro, vamos verificar quais tarefas estão sendo executadas atualmente:

jobs

Você deve ver sua tarefa em segundo plano em execução:

[1]  + running    ~/project/background_task.sh

Se você quiser informações mais detalhadas, incluindo o ID do processo (PID), use:

jobs -l

Isso exibirá uma saída semelhante a:

[1]  + 1456 running    ~/project/background_task.sh

Observe o PID (o número após o número da tarefa), pois ele pode ser usado para terminar o processo.

Método 1: Terminando uma Tarefa Usando Seu Número de Tarefa

A maneira mais direta de terminar uma tarefa em segundo plano é usar o comando kill com o número da tarefa:

kill %1

Verifique se a tarefa foi terminada:

jobs

Você pode ver:

[1]  + terminated  ~/project/background_task.sh

Se a tarefa ainda estiver em execução (alguns processos podem exigir um sinal de terminação mais forte), você pode usar:

kill -9 %1

A flag -9 envia um sinal SIGKILL, que termina o processo à força sem permitir que ele faça a limpeza.

Método 2: Terminando uma Tarefa Usando Seu PID

Vamos iniciar outra instância do nosso script em segundo plano:

~/project/background_task.sh &

Você deve ver a saída mostrando o número da tarefa e o PID:

[1] 1567

Para terminar esta tarefa usando seu PID, use:

kill 1567

Substitua 1567 pelo PID real da sua tarefa.

Verifique se a tarefa foi terminada:

jobs

Método 3: Usando o Nome do Processo com killall

Vamos iniciar mais uma instância do nosso script:

~/project/background_task.sh &

Se você tiver várias instâncias do mesmo processo em execução, você pode terminá-las todas de uma vez usando o comando killall:

killall background_task.sh

Este comando termina todos os processos com o nome background_task.sh.

Verifique se nenhuma tarefa está em execução:

jobs

Não deve haver saída, indicando que todas as tarefas em segundo plano foram terminadas.

Entendendo os Sinais de Terminação

Ao usar o comando kill, você está enviando um sinal para o processo. Por padrão, kill envia o sinal SIGTERM (sinal 15), que solicita que o processo termine graciosamente. Se um processo não responder ao SIGTERM, você pode usar SIGKILL (sinal 9) para forçar a terminação:

kill -TERM %1 ## Same as kill %1
kill -KILL %1 ## Same as kill -9 %1

Outros sinais úteis incluem:

• SIGHUP (sinal 1): Frequentemente usado para recarregar arquivos de configuração
• SIGINT (sinal 2): O mesmo que pressionar Ctrl+C
• SIGSTOP (sinal 19): Suspende um processo (não pode ser capturado ou ignorado)
• SIGCONT (sinal 18): Continua um processo interrompido

Para uma demonstração final, vamos iniciar nossa tarefa em segundo plano novamente e, em seguida, terminá-la:

~/project/background_task.sh &
jobs
kill %1
jobs

Esta sequência inicia a tarefa, confirma que ela está em execução, termina-a e, em seguida, verifica se ela não está mais em execução.

Resumo

Neste laboratório, você aprendeu habilidades essenciais para gerenciar tarefas em um ambiente Linux:

1. Iniciando Tarefas em Segundo Plano: Você aprendeu como executar processos em segundo plano usando o símbolo &, o que permite que você continue trabalhando no terminal enquanto tarefas de longa duração são executadas.

2. Verificando o Status da Tarefa: Você usou o comando jobs para visualizar informações sobre as tarefas em execução, incluindo seu estado, número da tarefa e ID do processo.

3. Trazendo Tarefas em Segundo Plano para Primeiro Plano: Você praticou trazer tarefas em segundo plano para o primeiro plano usando o comando fg, o que permite que você interaja com elas diretamente.

4. Suspendendo e Retomando Tarefas: Você aprendeu como suspender tarefas em primeiro plano em execução com Ctrl+Z e retomá-las, seja em primeiro plano (fg) ou em segundo plano (bg).

5. Terminando Tarefas: Você explorou diferentes maneiras de terminar tarefas quando elas não são mais necessárias, incluindo o uso do comando kill com números de tarefas ou PIDs, e o uso de killall para terminar vários processos por nome.

Essas habilidades de gerenciamento de tarefas são valiosas para qualquer usuário Linux, especialmente ao trabalhar com processos de longa duração ou ao realizar multitarefas em um ambiente de terminal. Ao controlar como e quando os processos são executados, você pode usar seus recursos do sistema de forma mais eficiente e otimizar seu fluxo de trabalho.

Lembre-se de que diferentes sinais podem ser usados com o comando kill para controlar o comportamento do processo, desde a terminação graciosa até a terminação forçada, dando a você um controle preciso sobre os processos do seu sistema.