Come posso eseguire un comando che sopravviverà alla chiusura del terminale?

A volte voglio iniziare un processo e non pensarci più. Se lo avvio dalla riga di comando, in questo modo:

redshift

Non riesco a chiudere il terminale, o ucciderà il processo. Posso eseguire un comando in modo tale da poter chiudere il terminale senza interrompere il processo?

Uno dei seguenti 2 dovrebbe funzionare:

$ nohup redshift &

o

$ redshift &
$ disown

Vedere di seguito per ulteriori informazioni su come funziona:

• man nohup

• help disown

• Differenza tra nohup, disown e & (assicurati di leggere anche i commenti)

Se il tuo programma è già in esecuzione , puoi metterlo in pausa Ctrl-Z, trascinarlo in background bge quindi disown, in questo modo:

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

La buona risposta è già pubblicata da @StevenD, ma penso che ciò potrebbe chiarire un po 'di più.

Il motivo per cui il processo viene interrotto al termine del terminale è che il processo avviato è un processo figlio del terminale. Una volta chiuso il terminale, questo ucciderà anche questi processi figlio. Puoi vedere l'albero dei processi con pstree, ad esempio quando kate &esegui in Konsole:

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

Per staccare il kateprocesso da konsolequando si termina konsole, utilizzare nohupcon il comando, in questo modo:

nohup kate &

Dopo la chiusura konsole, pstreesarà simile al seguente:

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

e katesopravviverà. :)

Un'alternativa sta usando screen/ tmux/ byobu, che manterrà la shell in esecuzione, indipendentemente dal terminale.

È possibile eseguire il processo in questo modo nel terminale

setsid process

Questo eseguirà il programma in una nuova sessione. Come spiegato http://hanoo.org/index.php?article=run-program-in-new-session-linux

Sebbene tutti i suggerimenti funzionino bene, ho scoperto che la mia alternativa è usare screen, un programma che imposta un terminale virtuale sullo schermo.

Potresti considerare di iniziare con . Lo schermo può essere installato praticamente su tutti i derivati ​​Linux e Unix. Colpire + e (lettere minuscole) inizierà una seconda sessione. Ciò consentirebbe di passare avanti e indietro tra la sessione iniziale premendo + e o la sessione più recente premendo + escreen -S session_nameCtrlACCtrlA0CtrlA1 . Puoi avere fino a dieci sessioni in un terminale. Avviavo una sessione di lavoro, tornavo a casa, ssh nella mia macchina di lavoro e poi invocavo . Questo ti riconnetterà a quella sessione remota.screen -d -R session_name

Il modo solo shell di fare tutto questo è chiudere stdin e in background il comando:

command <&- & 

Quindi non si chiuderà quando si esce dalla shell. Il reindirizzamento di stdout è una cosa facoltativa da fare.

Lo svantaggio è che non puoi farlo dopo il fatto.

Ho una sceneggiatura per:

• Esegui comandi arbitrari in background

• Impedisci loro di essere uccisi con la finestra del terminale

• Sopprime il loro output

• Gestisce lo stato di uscita

Lo uso principalmente per gedit, ecc. evince, inkscapeChe hanno tutti un output terminale fastidioso. Se il comando termina prima TIMEOUT, viene restituito lo stato di uscita di nohup anziché 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

esempi ...

>>> 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

Preferisco:

(Nome dell'applicazione &)

per esempio: linux@linux-desktop:~$ (chromium-browser &)

Assicurati di usare la parentesi quando digita il comando!

È possibile impostare un processo (PID) per non ricevere un segnale HUP al logout e alla chiusura della sessione del terminale. Utilizzare il comando seguente:

nohup -p PID

Probabilmente simile alla risposta offerta da apolinsky , utilizzo una variante su screen. Il comando vanilla è così

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

La sessione può essere disconnessa Ctrl ACtrl De ricollegata nel caso semplice con screen -r. Ho questo avvolto in uno script chiamato sessionche vive nel mio PATHpronto per un comodo accesso:

#!/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

Funziona solo quando sai in anticipo che vuoi disconnettere un programma. Non prevede la disconnessione di un programma già in esecuzione .

Analogamente ad altre risposte precedentemente pubblicate, è possibile trasferire un processo in esecuzione per utilizzare retrospettivamente lo "schermo" grazie a reptyr e quindi chiudere il terminale. I passaggi sono descritti in questo post . I passi da compiere sono:

1. Sospendi il processo
2. Riprendi il processo in background
3. Nega il processo
4. Avvia una sessione schermo
5. Trova il PID del processo
6. Utilizzare reptyr per assumere il controllo del processo