O que acontece com os sinais solicitados recursivamente?

Question

As pessoas geralmente atingem Ctrl + c ou Ctrl + z para cancelar ou abandonar o trabalho se o processo ficar lento; nesse caso, quais desses sinais são processados, o primeiro um ou o último um? é cada sinal processado? se não, então quais são ignorados ?

    

Answer 1

Os sinais são enviados na ordem em que você os digita via terminal para o kernel. Se você usar Ctrl + C você está instruindo o kernel a enviar o sinal SIGINT, para o grupo de processos em primeiro plano. Ao receber isso, o comando que estava em execução será encerrado.

Com um Ctrl + Z você está enviando o sinal SIGSTP. O que realmente não mata o processo, apenas diz para parar temporariamente. Quando isso é usado, você pode retomar o processo, dizendo ao shell para trazê-lo de volta ao primeiro plano, através do comando fg , ou você pode fazer o background com o comando bg .

Se um trabalho foi parado através do sinal SIGSTP, então você pode realmente matá-lo com o comando kill da seguinte forma:

$ kill %1

Onde %1 é o ID do trabalho que você acabou de SIGSTP.

Verificando os trabalhos parados

Você pode usar o comando job para ver quais trabalhos foram parados em um shell da seguinte forma:

$ sleep 1000 
^Z
[1]+  Stopped                 sleep 1000
$ jobs
[1]+  Stopped                 sleep 1000

Aqui eu usei Ctrl + Z para parar meu comando sleep 1000 . Na saída, o [1] corresponde ao %1 que mencionei acima. Matá-lo assim teria o mesmo efeito que o Ctrl + C .

$ kill %1
[1]+  Terminated              sleep 1000

O comando fg e bg que mencionei acima atuaria na tarefa que possui o sinal de mais, + após seu número. Observe aqui, em jobs output:

[1]+  Stopped                 sleep 1000

É mais óbvio se eu tiver alguns trabalhos, por exemplo:

$ jobs
[1]   Stopped                 sleep 1000
[2]-  Stopped                 sleep 2000
[3]+  Stopped                 sleep 3000

Assim, qualquer comando fg ou bg nulo agirá no trabalho com o + . Posso segmentar um específico como esse:

$ fg %1
sleep 1000

    

Answer 2

Se o destinatário tiver tempo para iniciar o processamento de um sinal antes do próximo, todos os sinais serão manipulados em ordem.

Quando um processo recebe um sinal, mas não está pronto para manipulá-lo (por exemplo, o sinal é mascarado ou o processo é interrompido), o kernel marca o sinal como pendente. O sinal será entregue.

Se vários sinais de números diferentes forem recebidos enquanto o processo não estiver pronto, todos os sinais serão manipulados. Os sinais são entregues ao processo um por um. A ordem em que são entregues é não especificada pelo POSIX ; em Linux , eles são entregues por número, o menor primeiro (por exemplo, SIGHUP = 1 será entregue primeiro se estiver pendente, então SIGQUIT = 2, etc.); FreeBSD não garante .

Se vários sinais com o mesmo número forem recebidos enquanto o processo não estiver pronto, esses sinais podem ser mesclados. O POSIX não especifica o que acontece, mas a maioria dos uniões se fundem. Por exemplo, se você executar kill -1 234; kill -1 234 , se o manipulador do processo 234 para o sinal 1 for recebido uma ou duas vezes é uma questão de tempo, isso depende se o 234 recebe um intervalo de tempo no qual o primeiro sinal é entregue.