Como posso executar um comando que sobreviverá ao fechamento do terminal?

Às vezes, quero iniciar um processo e esquecê-lo. Se eu iniciá-lo na linha de comando, assim:

redshift

Não consigo fechar o terminal ou isso acabará com o processo. Posso executar um comando para fechar o terminal sem interromper o processo?

Um dos 2 a seguir deve funcionar:

$ nohup redshift &

ou

$ redshift &
$ disown

Veja o seguinte para obter mais informações sobre como isso funciona:

• man nohup

• help disown

• Diferença entre nohup, renegado e & (não deixe de ler os comentários também)

Se o seu programa já estiver em execução, você pode pausá-lo Ctrl-Z, puxá-lo para segundo plano bge, em seguida disown, da seguinte maneira:

$ sleep 1000
^Z
[1]+  Stopped                 sleep 1000
$ bg
$ disown
$ exit

A boa resposta já foi publicada por @StevenD, mas acho que isso pode esclarecer um pouco mais.

O motivo pelo qual o processo é interrompido na finalização do terminal é que o processo iniciado é um processo filho do terminal. Depois de fechar o terminal, isso também matará esses processos filhos. Você pode ver a árvore de processos com pstree, por exemplo, ao executar kate &no Konsole:

init-+
     ├─konsole─┬─bash─┬─kate───2*[{kate}]
     │         │      └─pstree
     │         └─2*[{konsole}]

Para tornar o kateprocesso desanexado konsolequando você termina konsole, use nohupcom o comando, como este:

nohup kate &

Após o fechamento konsole, pstreeficará assim:

init-+
     |-kate---2*[{kate}]

e katevai sobreviver. :)

Uma alternativa é usar screen/ tmux/ byobu, que manterá o shell em execução, independente do terminal.

Você pode executar o processo como este no terminal

setsid process

Isso executará o programa em uma nova sessão. Como explicado http://hanoo.org/index.php?article=run-program-in-new-session-linux

Embora todas as sugestões funcionem bem, descobri que minha alternativa é usar screen, um programa que configura um terminal virtual na tela.

Você pode pensar em iniciá-lo . A tela pode ser instalada em praticamente todos os derivados Linux e Unix. Pressionar + e (em minúsculas) iniciará uma segunda sessão. Isso permitiria alternar entre a sessão inicial pressionando + e ou a sessão mais recente pressionando + e . Você pode ter até dez sessões em um terminal. Eu costumava iniciar uma sessão no trabalho, ir para casa, ssh na minha máquina de trabalho e depois invocar . Isso reconectará você a essa sessão remota.screen -S session_nameCtrlACCtrlA0CtrlA1screen -d -R session_name

A maneira apenas de shell de fazer tudo isso é fechar o stdin e colocar em segundo plano o comando:

command <&- & 

Então não será encerrado quando você sair do shell. Redirecionar stdout é uma boa opção opcional.

A desvantagem é que você não pode fazer isso depois do fato.

Eu tenho um script para:

• Executar comandos arbitrários em segundo plano

• Impeça que sejam mortos com a janela do terminal

• Suprimir sua saída

• Lida com o status de saída

Eu o uso principalmente para gedit, etc evince, inkscapetodos com muita saída terminal irritante. Se o comando terminar antes TIMEOUT, o status de saída do nohup será retornado em vez de zero.

#!/bin/bash

TIMEOUT=0.1

#use nohup to run the command, suppressing its output and allowing the terminal to be closed
#also send nohup's output to /dev/null, supressing nohup.out
#run nohup in the background so this script doesn't block
nohup "${@}" >/dev/null 2>&1 &
NOHUP_PID=$!

#kill this script after a short time, exiting with success status - command is still running
#this is needed as there is no timeout argument for `wait` below
MY_PID=$$
trap "exit 0" SIGINT SIGTERM
sleep $TIMEOUT && kill $MY_PID 2>/dev/null & #ignore "No such process" error if this exits normally

#if the command finishes before the above timeout, everything may be just fine or there could have been an error
wait $NOHUP_PID
NOHUP_STATUS=$?
#print an error if there was any. most commonly, there was a typo in the command
[ $NOHUP_STATUS != 0 ] && echo "Error ${@}"
#return the exit status of nohup, whatever it was
exit $NOHUP_STATUS

exemplos...

>>> run true && echo success || echo fail
success
>>> run false && echo success || echo fail
Error false
fail
>>> run sleep 1000 && echo success || echo fail
success
>>> run notfound && echo success || echo fail
Error notfound
fail

Eu prefiro:

(Nome da Aplicação &)

por exemplo: linux@linux-desktop:~$ (chromium-browser &)

Certifique-se de usar parênteses ao digitar o comando!

Você pode definir um processo (PID) para não receber um sinal HUP ao sair e fechar a sessão do terminal. Use o seguinte comando:

nohup -p PID

Indiscutivelmente semelhante à resposta oferecida por apolinsky , uso uma variante em screen. O comando vanilla é assim

screen bash -c 'long_running_command_here; echo; read -p "ALL DONE:"'

A sessão pode ser desconectada Ctrl ACtrl De reconectada no caso simples com screen -r. Eu tenho isso envolto em um script chamado sessionque mora no meu PATHpronto para acesso conveniente:

#!/bin/bash
#
if screen -ls | awk '$1 ~ /^[1-9][0-9]*\.'"$1"'/' >/dev/null
then
    echo "WARNING: session is already running (reattach with 'screen -r $1')" >&2
else
    exec screen -S "$1" bash -c "$@; echo; echo '--------------------'; read -p 'ALL DONE (Enter to exit):'"
    echo "ERROR: 'screen' is not installed on this system" >&2
fi
exit 1

Isso só funciona quando você sabe com antecedência que deseja desconectar um programa. Ele não prevê que um programa já em execução seja desconectado.

Da mesma forma que outras respostas postadas anteriormente, pode-se transferir um processo em execução para usar a "tela" retrospectivamente, graças ao reptyr e depois fechar o terminal. Os passos estão descritos nesta publicação . Os passos a seguir são:

1. Suspender o processo
2. Retomar o processo em segundo plano
3. Negar o processo
4. Iniciar uma sessão de tela
5. Encontre o PID do processo
6. Use reptyr para assumir o processo