Veja aqui
Existem dois sinais que podem suspender a execução de um processo. Um é "gracioso" e o outro é "vigoroso".
O "gracioso" é SIGTSTP
, e seu objetivo é "gentilmente" pedir ao processo, se lhe parecer, suspender a execução até receber um SIGCONT
. No caso de SIGTSTP
, o processo pode ignorar o SIGTSTP e continuar executando de qualquer maneira, portanto, isso requer cooperação de um programa projetado para lidar com o SIGTSTP.
O "forçado" é SIGSTOP
, e seu objetivo é suspender todos os threads de espaço do usuário associados a esse processo. É tão impossível para o processo ignorar SIGSTOP
quanto é para ignorar SIGKILL
(o último mata o processo com força).
Para enviar um sinal arbitrário, incluindo qualquer dos mencionados aqui, você pode usar programas como kill
, killall
, ou pkill
; ou use a chamada do sistema kill(2)
. Consulte as páginas de manual do seu sistema operacional para obter detalhes e erratas dependentes da plataforma / arquitetura / versão e qualquer uma das opções acima. Observe que a palavra "matar" em todos esses comandos e o syscall é um nome impróprio incorreto. Esses comandos não foram projetados, exclusivamente, para finalizar processos. Eles podem fazer isso enviando certos sinais; mas os sinais também podem ser usados para outras funções além de terminar um processo. Por exemplo, SIGSTOP
apenas suspende o processo e é apenas um dos vários sinais que podem ser enviados dessa maneira.
Para adicionar uma condição de retomar automaticamente o processo após um período de tempo, você precisará usar algum tipo de processo de monitoramento que permaneça em execução e definir um temporizador para ativar o processo de monitoramento, que, por sua vez, chama kill(2)
novamente e envia o SIGCONT
sinal para o processo parado, a fim de solicitar que o kernel retome a execução. Observe que o Linux possui vários mecanismos de temporização com vários graus de exatidão e precisão; além disso, se o seu sistema estiver muito ocupado, seu processo de monitoramento poderá não ser ativado até bem depois que o cronômetro expirar e, portanto, a ativação poderá ser atrasada.
Se depender de precisão muito precisas de suspensão e retomada do processo de suspensão, pode ser necessário para executar o seu programa de monitoramento com permissões em tempo real (ver esta página de manual on sched_setscheduler(2)
para obter informações sobre como fazer seu processo em tempo real). Você também pode usar temporizadores de alta resolução, um recurso do kernel Linux (disponível apenas se o seu hardware oferecer suporte a eles), em combinação com agendamento em tempo real, para obter uma precisão muito precisa, abaixo de milissegundos, no momento certo. ative e envie o sinal para retomar o processo monitorado muito rapidamente.
Você não indicou quais tecnologias deseja usar para implementar isso. No mínimo, você precisará de pelo menos scripts bash, embora não seja possível obter um tempo muito detalhado dessa maneira. Aqui está um "script" bash (não testado, portanto, tenha cuidado) que é apenas uma prova do conceito de sua consulta. Se você precisar de tempo preciso, precisará escrever um programa, provavelmente em C / C ++ ou outro idioma nativo, e usar agendamento e hrtimers em tempo real.
#!/bin/bash
#This is the process you want to suspend.
screen -mdS child bash -c "cat /dev/urandom | base64"
#This is the process ID of the child process
THEPID=$(screen -list | grep child | cut -f1 -d'.' | sed 's/\W//g')
#Send SIGSTOP to the child process.
kill -SIGSTOP ${THEPID}
#Now it is suspended. This process will sleep for 10 seconds asynchronously, then resume the process.
screen -mdS monitor bash -c "sleep 10; kill -SIGCONT ${THEPID}"
Observe que o script será finalizado e o script de controle será encerrado, mas, devido ao screen
controle do processo do monitor, ele continuará sendo executado em segundo plano por 10 segundos (com base no argumento passado para sleep
) e, em seguida, será ativado e continuará o processo filho. Mas isso será muito tempo depois que o script de controle terminar. Se você deseja esperar de forma síncrona o tempo decorrido, basta omitir a segunda chamada screen
e codificar permanentemente o sono e interromper o script de controle.
Você pode testar se o processo realmente suspende executando
screen -rS child
depois de iniciar esse script. Você não verá nada no console. Depois que o timer expirar (10 segundos), ele inundará sua tela com dados base64 (caracteres aleatórios de 0 a 9 e AF). Pressione Ctrl + C para sair.
Sim, você pode fazer isso enviando um sinal de STOP para um processo para suspendê-lo e, em seguida, um CONT para continuar.
uso:
fonte
Se você tiver uma definição adequada de "congelar", verifique o
renice
comando.Renice permite alterar a prioridade de agendamento dos processos em execução.
O valor normal do processo normal é 0. Aumentar o valor legal torna o processo mais agradável, como em "por que você não vai primeiro". Embora diminuir o valor agradável torne um processo menos agradável, como em "saia do meu caminho, estou com pressa". O intervalo de valor agradável é de -20 a 19.
Qualquer um pode tornar seus próprios processos mais agradáveis. Somente o root pode tornar um processo menos agradável ou alterar a gentileza de outros usuários.
Se você definir um valor legal de processos como 19, ele será executado apenas quando nada mais o sistema desejar.
Aqui está um exemplo executado na minha caixa linux local.
Use
ps -l
e observe a coluna NI para ver um valor agradável dos processos.A execução
renice +10
no processo vim faz com que seja executada com uma prioridade mais baixa.Supondo que você possa esticar "congelar" para significar "não incomodar mais ninguém no sistema", você pode criar um script como:
(lembre-se de executá-lo como root).
note que tomei algumas liberdades com a
ps -l
saída acima para fazer com que as colunas interessantes aparecessem bem nas pequenas caixas azuis :)fonte