Comando nohup: uso, nohup.out e come continuare l'esecuzione dopo aver chiuso il terminale

Per far continuare un lavoro anche se chiudi il terminale o cade la connessione SSH, avvialo con il comando nohup. nohup esegue il comando facendogli ignorare il segnale di disconnessione (SIGHUP) che arriva quando il terminale si chiude. Su un server AlmaLinux 9 sono stati avviati insieme uno sleep con nohup e uno senza, poi il terminale è stato chiuso: è rimasto in esecuzione solo quello avviato con nohup.

L'output qui sotto proviene da un server AlmaLinux 9.8 (account root) e da un server Debian 12 (account normale). Al posto di un lavoro lungo è stato avviato sleep, e per terminarlo è stato indicato solo il PID ricevuto all'avvio. Gli orari sono in UTC.

1️⃣ Come usare il comando nohup

nohup si mette davanti al comando da eseguire, e la & alla fine del comando imposta l'esecuzione in background. Secondo il manuale ufficiale GNU, nohup da solo non manda il comando in background, quindi senza la & il prompt non torna finché il comando non finisce.

nohup sleep 300 &

[1] 3431609
nohup: ignoring input and appending output to 'nohup.out'

[1] è il numero del job e 3431609 il PID del processo avviato. Il messaggio che segue avvisa che l'input da tastiera non viene letto e che l'output viene aggiunto al file nohup.out.

Il PID del job appena avviato resta in $!. Controllalo con [echo $!] subito dopo l'avvio e annotalo: userai lo stesso numero per vederne lo stato o per terminarlo.

echo $!

3431609

Quando il terminale si chiude, la shell riceve il segnale di disconnessione e invia lo stesso segnale ai job che ha avviato (secondo il manuale ufficiale di Bash). Per verificarlo, in un nuovo terminale sono stati avviati insieme [nohup sleep 300 &] e, senza nohup, [sleep 301 &].

sleep 301 &

[2] 3432892

jobs -l

[1]- 3432883 Running                 nohup sleep 300 &
[2]+ 3432892 Running                 sleep 301 &

Con entrambi i job in Running, la finestra del terminale è stata chiusa e i due PID sono stati controllati con ps da un'altra shell.

ps -p 3432883,3432892 -o pid,stat,etime,cmd

    PID STAT     ELAPSED CMD
3432883 S          00:05 sleep 300

È rimasto solo sleep 300, avviato con nohup; sleep 301, avviato senza nohup, è terminato alla chiusura del terminale.

Un processo avviato con nohup è come un telefono in modalità Non disturbare.

nohup è un comando del pacchetto coreutils. La versione installata si vede nella prima riga di --version. Il server AlmaLinux 9.8 aveva la 8.32, il server Debian 12 la 9.1.

nohup --version | head -1

nohup (GNU coreutils) 8.32

nohup --version | head -1

nohup (GNU coreutils) 9.1

2️⃣ nohup.out e reindirizzamento dell'output

Se non indichi dove va l'output, nohup aggiunge l'output del comando a nohup.out nella cartella corrente. Il nohup.out appena creato era di 0 byte, con permessi -rw-------, cioè lettura e scrittura solo per l'utente che l'ha creato.

ls -l nohup.out

-rw------- 1 root root 0 Oct 28 23:04 nohup.out

Il manuale ufficiale GNU spiega che nohup crea nohup.out in modo che solo l'utente che l'ha creato possa leggerlo e scriverlo, indipendentemente dall'impostazione di umask. Se non può scrivere nella cartella corrente, scrive in $HOME/nohup.out nella cartella home, e se non può scrivere nemmeno lì, non esegue il comando.

Eseguendo con nohup un comando che produce output, l'output è rimasto in nohup.out dopo la fine del comando.

nohup sh -c 'echo start; sleep 2; echo end' &

[1] 3431985
nohup: ignoring input and appending output to 'nohup.out'

cat nohup.out

start
end
[1]+  Done                    nohup sh -c 'echo start; sleep 2; echo end'

Il Done nell'ultima riga è l'avviso della shell che il job è terminato. nohup.out non viene ricreato a ogni esecuzione ma continua alla fine dello stesso file, quindi se avvii più job dalla stessa cartella, i loro output si mescolano in un unico file.

Per tenere un log separato per ogni job, imposta il file di output con > e manda anche l'output degli errori nello stesso file con 2>&1.

nohup sh -c 'echo start; sleep 300' > job.log 2>&1 &

[1] 3432059

cat job.log

nohup: ignoring input
start

Aggiungendo anche 2>&1, il terminale ha mostrato solo il numero del job e il PID, e l'avviso di nohup [nohup: ignoring input] è finito nella prima riga del file di log.

Se aggiungi solo > e togli 2>&1, nel terminale compare un avviso che l'output degli errori viene reindirizzato al file dell'output standard.

nohup sleep 300 > job2.log &

[2] 3432097
nohup: ignoring input and redirecting stderr to stdout

L'output dei job che non serve conservare va mandato a /dev/null. Anche in questo caso il terminale ha mostrato solo il numero del job e il PID.

nohup sleep 300 > /dev/null 2>&1 &

[3] 3432137

La tabella qui sotto mostra, per i quattro modi di esecuzione, dove è finito l'output e quale messaggio è comparso nel terminale.

3️⃣ Controllare e terminare i processi nohup

L'elenco di jobs mostra solo i job avviati dalla shell corrente, quindi dopo aver chiuso il terminale ed esserti ricollegato controlla il processo nohup con ps -p indicando il PID. Finché resti nella stessa shell, jobs -l mostra insieme numero del job, PID e stato.

jobs -l

[1]+ 3431609 Running                 nohup sleep 300 &

Scrivendo un PID dopo ps -p e scegliendo le colonne con -o, compare solo la riga di quel processo. La S in STAT indica che il processo dorme in attesa di un evento, ed ELAPSED è il tempo trascorso dall'avvio.

ps -p 3431609 -o pid,stat,etime,cmd

    PID STAT     ELAPSED CMD
3431609 S          00:03 sleep 300

Per terminarlo usa kill seguito dal PID.

kill 3431609

kill non ha stampato nulla e, eseguendo subito dopo jobs, il job è comparso come Terminated ed è poi uscito dall'elenco.

jobs

[1]+  Terminated              nohup sleep 300

Rieseguendo ps con lo stesso PID è comparsa solo l'intestazione, a conferma che il processo era terminato.

ps -p 3431609 -o pid,stat,etime,cmd

    PID STAT     ELAPSED CMD

nohup ignora solo il segnale di disconnessione, quindi anche inviando direttamente lo stesso segnale con [kill -HUP] il processo non termina. kill -HUP è stato inviato a sleep 305, avviato con nohup, e a sleep 306, avviato senza.

kill -HUP 3437119 3437128

Il controllo successivo con jobs -l ha mostrato ancora in Running solo quello con nohup, mentre sleep 306 è terminato con Hangup.

jobs -l

[1]- 3437119 Running                 nohup sleep 305 &
[2]+ 3437128 Hangup                  sleep 306

Se non indichi un segnale a kill, invia SIGTERM, quindi anche un job avviato con nohup termina con [kill PID].

4️⃣ Comando nohup e disown a confronto, opzioni

🔲 nohup e disown a confronto

disown è un comando interno di bash che si usa sui job già avviati: serve a staccare in un secondo momento dal segnale di disconnessione del terminale un job avviato con & ma senza nohup. disown non reindirizza l'output su nohup.out, quindi per un job che produce output decidi dove mandarlo con > file già all'avvio.

Secondo il manuale ufficiale di Bash, disown senza opzioni toglie il job dall'elenco di jobs, mentre disown -h lo lascia nell'elenco e impedisce solo che gli arrivi il segnale di disconnessione. Prima è stato avviato sleep 302 e poi eseguito disown.

sleep 302 &

[1] 3433230

disown

disown non ha stampato nulla, e anche jobs -l, eseguito subito dopo, ha dato un risultato vuoto.

jobs -l

Poi è stato avviato sleep 303 ed eseguito disown -h sul numero di job %1.

sleep 303 &

[1] 3433343

disown -h %1

Il controllo con jobs -l ha mostrato il job ancora nell'elenco.

jobs -l

[1]+ 3433343 Running                 sleep 303 &

È stato avviato anche un altro sleep 304 senza alcun trattamento, il terminale è stato chiuso e i tre PID sono stati controllati da un'altra shell.

sleep 304 &

[2] 3433474

ps -p 3433230,3433343,3433474 -o pid,stat,etime,cmd

    PID STAT     ELAPSED CMD
3433230 S          00:11 sleep 302
3433343 S          00:08 sleep 303

I due job con disown e disown -h sono rimasti, ed è terminato solo sleep 304, senza trattamento. Ecco i quattro metodi a confronto.

Per i lavori in cui devi richiamare la schermata della sessione e continuare a digitare va bene un multiplexer di terminale come tmux; per quelli che avvii una volta e di cui ricevi solo il risultato in un file, basta nohup.

🔲 Opzioni del comando nohup

📌 Opzioni principali: risultati di questo articolo

📎 Altre opzioni: secondo il manuale ufficiale

🔲 Simulatore del comando nohup

Nel simulatore qui sotto puoi avviare un job con nohup, chiudere il terminale e ricollegarti con il chip 🔌 e vedere da te quali processi restano.

🔢 FAQ & contenuti consigliati

🔗 Contenuti consigliati

Processi Comando ps (comando dei processi) Il comando ps, che mostra i processi in esecuzione. Dopo aver riaperto il terminale trova tramite PID anche i job che jobs non mostra più. Leggi l'articolo →

Pianificazione Linux: configurazione di crontab Configurazione di crontab, lo scheduler di Linux che registra lavori da ripetere a orari fissi, come backup o pulizia dei log. Priorità Comando nice di Linux: impostare la priorità, cambiarla con renice e misurare la quota di CPU in competizione Come impostare il valore nice, che decide quanta CPU un programma cede quando gira, e come cambiarlo con renice. Processi Comando top di Linux (controllare l'uso di CPU e memoria) Il comando top, che mostra in tempo reale l'uso di CPU e memoria per processo.

ℹ️ Informativa sull'affiliazione
I contenuti di questo sito includono link di affiliazione. Se un visitatore acquista un prodotto o un servizio tramite uno di questi link, il sito riceve una commissione dal venditore. In questo processo l'importo pagato dall'acquirente ^{(durante le promozioni l'importo scende↓)} non aumenta. Prezzi, sconti e disponibilità indicati si riferiscono al momento della stesura e possono differire da quelli reali: prima di acquistare verifica sempre presso il venditore. I prodotti vengono scelti e valutati secondo criteri propri, e le commissioni non influiscono sull'ordine di presentazione né sul contenuto delle valutazioni.