Ogni volta che eseguiamo un comando, vengono avviati uno o piu' processi.
## Controllare i job
I *job* sono processi che sono stati avviati in modo interattivo tramite una shell, inviati in background e non hanno terminato l'esecuzione. Per scoprire i job attivi, digitare sul terminale il comando:
```bash
> jobs
[1]+ Stopped sleep 60
```
- Il simbolo `[1]` rappresenta l'ID del job e puo' essere usato, preceduto dal simbolo `%`, per cambiare lo stato del job, attraverso le utility `fg`, `bg`, e `kill`.
-`+`: indica il job corrente, ovvero l'ultimo messo in background. Il job precedente e' contrassegnato da un segno `-`. Eventuali altri job precedenti non sono contrassegnati
-`Stopped`: indica lo stato del job
-`sleep 60`: il comando
Con l'opzione `-l` viene mostrato anche il `PID` del processo:
```bash
> jobs -l
[1]+ 13637 Fermato sleep 60
```
> Un job ha sia un job ID che un process ID (PID)
### Stato dei job
Una volta che un job e' in background o sospeso:
- Portarlo in primo piano con `fg`
```bash
> fg %1
sleep 60
```
- Portarlo in background con `bg`
```bash
> bg %1
[1]+ sleep 60 &
```
- Terminarlo col comando `kill`
```bash
> kill %1
[1]+ Terminato sleep 60
```
### Detach dei job: nohup
Negli esempi precedenti, i job erano legati alla sessione dell'utente. Se termina, terminano anche i job. E' possibile scollegare un job dalla sessione, in modo che, se termina la sessione, non viene terminato anche il job.
```bash
nohup COMMAND &
```
Nel file `nohup.out` verranno salvati *stdin* e *stderr* in modo predefinito.
```bash
> nohup ping localhost &
[1] 14081
nohup: input ignorato e output accodato a 'nohup.out'
```
Nel caso volessimo indicare un file personalizzato: `nohup ping localhost > /path/to/file &`
Per terminare il processo: `kill %1` oppure `kill 14081`
## Controllare i processi
Un processo e' un'istanza di un programma in esecuzione.
### Inviare segnali ai processi
Ogni processo ha un identificatore univoco o `PID`. Un modo per scoprirlo e' tramite il comando `pgrep PROCESS_NAME`
```bash
> pgrep sleep
14384
14515
```
Oppure anche tramite:
```bash
> pidof sleep
14515 14384
```
Il comando `pkill` termina il processo. Per terminare tutte le istanze dello stesso processo, e' possibile utilizzare il comando `killall`. I comandi `kill`, `pkill` e `killall` inviano un segnale di terminazione al processo. Se non specificato, viene inviato il valore predefinito di SIGTERM. I segnali di terminazione possono essere specificati anche mediante numero. Usare `kill -9` per terminare un processo quando qualsiasi altro segnale fallisce.
### Segnali di terminazione
Il segnale SIGTERM (*Signal Terminate*) è uno dei segnali utilizzati nel sistema operativo Unix e nei suoi derivati per gestire la terminazione dei processi. Quando un processo riceve un segnale SIGTERM, viene avvisato di terminare in modo controllato. Questo significa che il processo ha la possibilità di eseguire operazioni di pulizia, come il salvataggio dei dati o la chiusura delle risorse aperte, prima di terminare.
Oltre a SIGTERM, ci sono altri segnali di terminazione:
- SIGKILL (Uccisione): Questo segnale forza la terminazione immediata del processo. Non può essere gestito o ignorato dal processo, e non consente alcuna operazione di pulizia. È utilizzato quando un processo non risponde a SIGTERM.
- SIGINT (Interruzione): Questo segnale viene inviato quando un utente preme Ctrl+C in un terminale. È simile a SIGTERM, in quanto consente al processo di gestire la terminazione in modo controllato.
Alcuni segnali possono essere ignorati, ma non SIGKILL e SIGSTOP.
```txt
SIGINT (2): Interrupt - Inviato quando l'utente preme Ctrl+C
SIGKILL (9): Kill - Termina un processo in modo forzato; non può essere catturato o ignorato
SIGSEGV (11): Segmentation Fault - Indica che un processo ha tentato di accedere a una memoria non valida
SIGTERM (15): Terminate - Richiesta di terminare un processo; può essere catturato e gestito dal processo
-`r`: *renice*, ossia cambia la priorita' di un processo. `top` chiedera' il valore di `nice`, compreso tra -20 e 19 (solo root puo' impostare il valore a un numero negativo o inferiore a quello attuale). Maggiore il valore, minore la priorita'.
