Controle de trabalho (Unix) - Job control (Unix)

Este artigo é sobre o controle de tarefas no sistema Unix. Para o termo geral, consulte controle de tarefas (computação) .

Em Unix e Unix-like sistemas operacionais , controle de trabalho refere-se a controlar de postos de trabalho por um shell , especialmente de forma interativa, onde um "trabalho" é a representação de um shell para um grupo de processos . Os recursos básicos de controle de trabalho são suspender, retomar ou encerrar todos os processos no trabalho / grupo de processos; recursos mais avançados podem ser executados enviando sinais para o trabalho. O controle de tarefas é de particular interesse no Unix devido ao seu multiprocessamento , e deve ser diferenciado do controle de tarefas em geral, que é frequentemente aplicado à execução sequencial ( processamento em lote ).

Visão geral

Ao usar Unix ou sistemas operacionais semelhantes ao Unix por meio de um terminal (ou emulador de terminal ), um usuário inicialmente terá apenas um único processo em execução, seu shell de login . A maioria das tarefas (listagem de diretórios, edição de arquivos, etc.) podem ser facilmente realizadas permitindo que o programa assuma o controle do terminal e retorne o controle ao shell quando o programa for encerrado - formalmente, anexando à entrada padrão e saída padrão ao shell, que lê ou escreve a partir do terminal, e captura sinais enviados do teclado, como o sinal de terminação resultante de pressionar + . ControlC

No entanto, às vezes o usuário desejará realizar uma tarefa enquanto usa o terminal para outra finalidade. Uma tarefa que está em execução, mas não está recebendo entrada do terminal, está sendo executada "em segundo plano", enquanto a única tarefa que está recebendo entrada do terminal está "em primeiro plano". O controle de trabalho é um recurso desenvolvido para tornar isso possível, permitindo ao usuário iniciar processos em segundo plano, enviar processos já em execução para segundo plano, trazer processos de segundo plano para o primeiro plano e suspender ou encerrar processos.

O conceito de uma tarefa mapeia o conceito (shell) de um único comando shell para o conceito (sistema operacional) dos possivelmente muitos processos que o comando envolve. As tarefas de multiprocessos surgem porque os processos podem criar processos filho adicionais, e um único comando shell pode consistir em um pipeline de vários processos de comunicação. Por exemplo, um comando para selecionar linhas contendo o texto "título", classificá-las em ordem alfabética e exibir o resultado em um pager . 

grep title somefile.txt | sort | less

Isso cria pelo menos três processos: um para grep , um para classificar e um para menos . O controle de tarefas permite que o shell controle esses processos relacionados como uma entidade e, quando um usuário emite a combinação de teclas apropriada (geralmente Control + Z ), todo o grupo de processos é suspenso.

Os trabalhos são gerenciados pelo sistema operacional como um único grupo de processos e o trabalho é a representação interna do shell desse grupo. Isso é definido no POSIX como:

Um conjunto de processos, compreendendo um pipeline de shell e quaisquer processos descendentes dele, que estão todos no mesmo grupo de processos.

Um trabalho pode ser referido por um identificador chamado ID de trabalho de controle de trabalho ou simplesmente ID de trabalho , que é usado por shell builtins para se referir ao trabalho. Os IDs de trabalho começam com o % caractere; %n identifica o trabalho n , enquanto %% identifica o trabalho atual. Outros IDs de trabalho são especificados por POSIX . No uso informal, o número pode ser referido como o "número do trabalho" ou "ID do trabalho", e a documentação do Bash se refere ao ID do trabalho (com o prefixo%) como a especificação do trabalho.

O controle de tarefas e os IDs de tarefas são normalmente usados ​​apenas em uso interativo, onde simplificam a referência a grupos de processos; em scripts, PGIDs são usados, pois são mais precisos e robustos e, de fato, o controle de tarefas é desabilitado por padrão em scripts bash.

História

O controle de tarefas foi implementado pela primeira vez no shell C por Jim Kulp, depois na IIASA na Áustria, fazendo uso dos recursos do kernel 4.1 BSD . O KornShell , desenvolvido no Bell Labs, o adotou e foi posteriormente incorporado à versão SVR4 do shell Bourne , e existe na maioria dos shells Unix modernos.

Comandos

O padrão POSIX especifica dois comandos para retomar trabalhos suspensos em segundo e primeiro plano, respectivamente bg e fg . Eles foram modelados a partir dos comandos de controle de tarefas do shell Korn.

Implementação

Normalmente, o shell mantém uma lista de trabalhos em uma tabela de trabalhos . Lembre-se de que um trabalho corresponde a um grupo de processos, que consiste em todos os membros de um pipeline e seus descendentes. O jobs comando listará os trabalhos de segundo plano existentes na tabela de trabalhos, junto com seu número de trabalho e estado do trabalho (interrompido ou em execução). Quando uma sessão termina quando o usuário efetua logout (sai do shell, o que encerra o processo líder da sessão ), o processo shell envia SIGHUP para todos os trabalhos e espera que os grupos de processos terminem antes de encerrar a si mesmo.

O disown comando pode ser usado para remover trabalhos da tabela de trabalhos, de forma que, quando a sessão termina, os grupos de processos filhos não são enviados SIGHUP, nem o shell espera que eles terminem. Assim, eles se tornam processos órfãos e podem ser encerrados pelo sistema operacional, embora seja mais frequentemente usado para que os processos sejam adotados pelo init (o kernel configura seu processo pai para init) e continuam executando como daemons . As alternativas para evitar que os trabalhos sejam encerrados incluem nohup e uso de um multiplexador de terminal .

Uma tarefa em execução em primeiro plano pode ser interrompida digitando o caractere suspenso ( Ctrl-Z ). Isso envia o sinal de "parada do terminal" ( SIGTSTP ) para o grupo de processo. Por padrão, SIGTSTP faz com que os processos que o recebem parem e o controle seja retornado ao shell. No entanto, um processo pode registrar um manipulador de sinal para ou ignorar o SIGTSTP. Um processo também pode ser pausado com o sinal de "parada" ( SIGSTOP ), que não pode ser capturado ou ignorado.

Uma tarefa em execução em primeiro plano pode ser interrompida digitando o caractere de interrupção ( Ctrl-C ). Isso envia o sinal de "interrupção" ( SIGINT ), cujo padrão é encerrar o processo, embora possa ser substituído.

Um trabalho interrompido pode ser retomado como trabalho em segundo plano com o bg builtin ou como trabalho em primeiro plano com fg . Em ambos os casos, o shell redireciona I / O apropriadamente e envia o sinal SIGCONT para o processo, o que faz com que o sistema operacional retome sua execução. No Bash , um programa pode ser iniciado como um trabalho em segundo plano anexando um e comercial ( & ) à linha de comando; sua saída é direcionada ao terminal (potencialmente intercalada com a saída de outros programas), mas não pode ler a partir da entrada do terminal.

Um processo em segundo plano que tenta ler ou gravar em seu terminal de controle é enviado um sinal SIGTTIN (para entrada) ou SIGTTOU (para saída). Esses sinais interrompem o processo por padrão, mas também podem ser tratados de outras maneiras. Os shells geralmente substituem a ação de parada padrão do SIGTTOU para que os processos em segundo plano entreguem sua saída ao terminal de controle por padrão.

Em shells compatíveis com Bash, o kill integrado (não /bin/kill ) pode sinalizar trabalhos por ID de trabalho, bem como por ID de grupo de processo - enviar um sinal para um trabalho envia-o para todo o grupo de processo, e os trabalhos especificados por um ID de trabalho devem ser eliminados por prefixando % . kill pode enviar qualquer sinal para um trabalho; entretanto, se a intenção é livrar o sistema dos processos, os sinais SIGKILL e SIGTERM (o padrão) são provavelmente os mais aplicáveis.

Veja também

Notas

Referências

Leitura adicional

links externos