{"id":3639,"date":"2026-07-18T08:45:39","date_gmt":"2026-07-18T06:45:39","guid":{"rendered":"https:\/\/rootmail.it\/courses\/lpic-1-exam-101-010-160-corso-completo-in-italiano\/lessons\/103-5-creare-monitorare-e-terminare-i-processi\/"},"modified":"2026-07-20T21:57:52","modified_gmt":"2026-07-20T19:57:52","slug":"103-5-creare-monitorare-e-terminare-i-processi","status":"publish","type":"lesson","link":"https:\/\/rootmail.it\/en\/courses\/lpic-1-exam-1-101-500-corso-completo-in-italiano\/lessons\/103-5-creare-monitorare-e-terminare-i-processi\/","title":{"rendered":"103.5 Creare, monitorare e terminare i processi"},"content":{"rendered":"

103.5 Creare, monitorare e terminare i processi<\/h2>\n

Ogni programma in esecuzione su un sistema Linux viene gestito come un processo<\/strong>. Dal semplice comando eseguito nel terminale ai servizi di sistema, fino alle applicazioni in background, tutto ci\u00f2 che viene eseguito dal sistema operativo \u00e8 rappresentato da uno o pi\u00f9 processi.<\/p>\n

Linux mette a disposizione numerosi strumenti per visualizzare i processi attivi, monitorarne il consumo di risorse, modificarne il comportamento e terminarli quando necessario. Queste competenze sono fondamentali per amministrare un sistema, individuare problemi di prestazioni e gestire applicazioni che non rispondono correttamente.<\/p>\n

In questa lezione imparerai a creare e controllare processi, interpretarli attraverso i principali strumenti di monitoraggio e utilizzare i comandi pi\u00f9 comuni per terminarli in modo sicuro.<\/p>\n

\ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere i comandi ps<\/code>, top<\/code>, pgrep<\/code>, pstree<\/code>, kill<\/code>, killall<\/code>, pkill<\/code>, nohup<\/code>, jobs<\/code>, bg<\/code>, fg<\/code> e comprendere il funzionamento dei processi in foreground e background.<\/p><\/blockquote>\n

\n

\ud83c\udfaf Obiettivi della lezione<\/h2>\n

Al termine di questa lezione sarai in grado di:<\/p>\n

    \n
  • comprendere cos’\u00e8 un processo e come viene identificato in Linux;<\/li>\n
  • visualizzare e monitorare i processi in esecuzione;<\/li>\n
  • eseguire programmi in foreground e background;<\/li>\n
  • ricercare processi specifici utilizzando diversi strumenti;<\/li>\n
  • terminare processi in modo corretto utilizzando i segnali appropriati.<\/li>\n<\/ul>\n
    \n

    Argomenti trattati<\/h2>\n
      \n
    • Cos’\u00e8 un processo e il PID (Process ID).<\/li>\n
    • Foreground e background.<\/li>\n
    • Visualizzazione dei processi con ps<\/code>, top<\/code> e pstree<\/code>.<\/li>\n
    • Ricerca dei processi con pgrep<\/code>.<\/li>\n
    • Terminazione dei processi con kill<\/code>, killall<\/code> e pkill<\/code>.<\/li>\n
    • Gestione dei processi con jobs<\/code>, bg<\/code>, fg<\/code> e nohup<\/code>.<\/li>\n
    • Best practice per il monitoraggio e la gestione dei processi.<\/li>\n<\/ul>\n

      \u2328\ufe0f Provalo subito<\/strong>
      \nApri un terminale Linux e avvia un programma semplice, come sleep 300<\/code>. Durante la lezione potrai utilizzarlo per sperimentare i comandi di monitoraggio, gestione e terminazione dei processi in totale sicurezza.<\/p><\/blockquote>\n

      103.5.1 Processi in foreground e background<\/h2>\n

      Quando un comando viene eseguito nella shell Linux, normalmente viene avviato in foreground<\/strong>, occupando il terminale fino al termine della sua esecuzione. Durante questo periodo il terminale non pu\u00f2 essere utilizzato per eseguire altri comandi.<\/p>\n

      Per attivit\u00e0 che richiedono molto tempo, Linux permette di eseguire un processo in background<\/strong>, lasciando immediatamente disponibile il terminale per continuare a lavorare.<\/p>\n

      \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere la differenza tra processi in foreground e background e sapere come avviare un processo in background utilizzando il simbolo &<\/code>.<\/p><\/blockquote>\n

      \n

      Eseguire un processo in foreground<\/h3>\n

      Per impostazione predefinita, qualsiasi comando viene eseguito in foreground.<\/p>\n

      Ad esempio:<\/p>\n

      sleep 30\r\n<\/code><\/pre>\n
      Il comando rimane in esecuzione per 30 secondi e il terminale resta occupato fino al termine dell’operazione.<\/p>\n
      \n
      Eseguire un processo in background<\/h3>\n
      Per avviare direttamente un processo in background \u00e8 sufficiente aggiungere il simbolo &<\/code> alla fine del comando.<\/p>\n
      Esempio:<\/p>\n
      long-running-command &\r\n<\/code><\/pre>\n
      oppure:<\/p>\n
      sleep 300 &\r\n<\/code><\/pre>\n
      La shell restituisce immediatamente il controllo del terminale, mentre il processo continua ad essere eseguito in background.<\/p>\n
      Generalmente viene visualizzato un output simile al seguente:<\/p>\n
      [1] 24561\r\n<\/code><\/pre>\n
      dove:<\/p>\n
        \n
      • 1<\/strong> rappresenta il numero del job;<\/li>\n
      • 24561<\/strong> rappresenta il PID (Process ID).<\/li>\n<\/ul>\n
        \n
        Quando utilizzare il background?<\/h3>\n
        L’esecuzione in background \u00e8 particolarmente utile per:<\/p>\n
          \n
        • backup di grandi quantit\u00e0 di dati;<\/li>\n
        • download di file di grandi dimensioni;<\/li>\n
        • compilazione di software;<\/li>\n
        • script che richiedono diversi minuti o ore per terminare.<\/li>\n<\/ul>\n
          In questo modo \u00e8 possibile continuare a utilizzare il terminale senza attendere la conclusione del comando.<\/p>\n
          \ud83d\udccc Da ricordare<\/strong> Un processo avviato con &<\/code> continua l’esecuzione in background mentre il terminale rimane disponibile per eseguire altri comandi.<\/p><\/blockquote>\n
          \n
          Best Practice<\/h3>\n
          Utilizza il background per processi di lunga durata che non richiedono interazione con l’utente. Per i programmi che necessitano di input da tastiera \u00e8 generalmente preferibile l’esecuzione in foreground.<\/p>\n
          \n
          Riepilogo<\/h3>\n
            \n
          • I processi in foreground occupano il terminale fino al termine dell’esecuzione.<\/li>\n
          • I processi in background permettono di continuare a utilizzare la shell.<\/li>\n
          • Il simbolo &<\/code> avvia un comando in background.<\/li>\n
          • La shell mostra il numero del job e il PID del processo avviato.<\/li>\n<\/ul>\n
            103.5.2 Gestire i processi in background<\/h2>\n
            Dopo aver avviato un processo in background, Linux mette a disposizione diversi strumenti per gestirlo. \u00c8 possibile sospendere temporaneamente un processo, riprenderne l’esecuzione in background, riportarlo in foreground oppure visualizzare l’elenco dei processi appartenenti alla sessione corrente.<\/p>\n
            Questi strumenti fanno parte della Job Control<\/strong>, una funzionalit\u00e0 integrata nella shell Bash che permette di amministrare facilmente i processi avviati dall’utente.<\/p>\n
            \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere i comandi jobs<\/code>, bg<\/code> e fg<\/code>, oltre alla combinazione di tasti Ctrl + Z<\/strong>.<\/p><\/blockquote>\n
            \n
            Sospendere un processo<\/h3>\n
            Un processo in esecuzione in foreground pu\u00f2 essere sospeso senza essere terminato premendo:<\/p>\n
            Ctrl + Z\r\n<\/code><\/pre>\n
            Il processo entra nello stato Stopped<\/strong> e il controllo ritorna immediatamente alla shell.<\/p>\n
            Ad esempio:<\/p>\n
            sleep 300\r\n<\/code><\/pre>\n
            Premendo Ctrl + Z<\/strong> verr\u00e0 visualizzato un messaggio simile a:<\/p>\n
            [1]+ Stopped    sleep 300\r\n<\/code><\/pre>\n
            Il processo non \u00e8 terminato, ma semplicemente sospeso.<\/p>\n
            \n
            Riprendere un processo in background<\/h3>\n
            Per continuare l’esecuzione di un processo sospeso in background si utilizza il comando:<\/p>\n
            bg\r\n<\/code><\/pre>\n
            Esempio:<\/p>\n
            sleep 300\r\n^Z\r\nbg\r\n<\/code><\/pre>\n
            Dopo il comando bg<\/code>, il processo riprender\u00e0 l’esecuzione senza occupare il terminale.<\/p>\n
            \n
            Riportare un processo in foreground<\/h3>\n
            Per riportare un processo in background nuovamente in foreground si utilizza:<\/p>\n
            fg\r\n<\/code><\/pre>\n
            Il terminale verr\u00e0 nuovamente associato al processo, consentendo all’utente di interagire con esso.<\/p>\n
            Se sono presenti pi\u00f9 job, \u00e8 possibile specificarne uno in particolare:<\/p>\n
            fg %1\r\n<\/code><\/pre>\n
            dove %1<\/code> rappresenta il numero del job.<\/p>\n
            \n
            Visualizzare i job attivi<\/h3>\n
            Il comando:<\/p>\n
            jobs\r\n<\/code><\/pre>\n
            mostra tutti i processi appartenenti alla shell corrente.<\/p>\n
            Ad esempio:<\/p>\n
            [1]- Running    sleep 300 &\r\n[2]+ Stopped    nano file.txt\r\n<\/code><\/pre>\n
            L’output indica:<\/p>\n
              \n
            • il numero del job;<\/li>\n
            • lo stato del processo (Running<\/strong>, Stopped<\/strong>, ecc.);<\/li>\n
            • il comando eseguito.<\/li>\n<\/ul>\n
              \n
              Workflow tipico<\/h3>\n
              Una sequenza molto comune \u00e8 la seguente:<\/p>\n
              sleep 300\r\nCtrl + Z\r\nbg\r\njobs\r\nfg\r\n<\/code><\/pre>\n
              Le operazioni eseguite sono:<\/p>\n
                \n
              1. avvio del processo in foreground;<\/li>\n
              2. sospensione mediante Ctrl + Z<\/strong>;<\/li>\n
              3. ripresa del processo in background con bg<\/code>;<\/li>\n
              4. visualizzazione dei job con jobs<\/code>;<\/li>\n
              5. ritorno del processo in foreground con fg<\/code>.<\/li>\n<\/ol>\n
                \n
                Comandi principali della Job Control<\/h3>\n\n\n\n\n\n\n\n\n
                Comando<\/th>\nFunzione<\/th>\n<\/tr>\n<\/thead>\n
                Ctrl + Z<\/code><\/td>\nSospende il processo in foreground.<\/td>\n<\/tr>\n
                bg<\/code><\/td>\nRiprende un processo sospeso in background.<\/td>\n<\/tr>\n
                fg<\/code><\/td>\nRiporta un processo in foreground.<\/td>\n<\/tr>\n
                jobs<\/code><\/td>\nVisualizza i job della shell corrente.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                \ud83d\udccc Da ricordare<\/strong> I comandi jobs<\/code>, bg<\/code> e fg<\/code> funzionano esclusivamente sui processi appartenenti alla shell corrente. Per gestire qualsiasi processo del sistema si utilizzano strumenti come ps<\/code>, pgrep<\/code> e kill<\/code>, che vedremo nelle prossime sezioni.<\/p><\/blockquote>\n
                \n
                Best Practice<\/h3>\n
                Quando sospendi accidentalmente un processo con Ctrl + Z<\/strong>, evita di lasciarlo nello stato Stopped<\/strong>. Decidi se riprenderlo in background con bg<\/code>, riportarlo in foreground con fg<\/code> oppure terminarlo, cos\u00ec da non lasciare processi inutilmente sospesi.<\/p>\n
                \n
                Riepilogo<\/h3>\n
                  \n
                • Ctrl + Z<\/strong> sospende il processo attualmente in esecuzione.<\/li>\n
                • bg<\/code> riprende un processo sospeso in background.<\/li>\n
                • fg<\/code> riporta un processo in foreground.<\/li>\n
                • jobs<\/code> mostra i processi appartenenti alla shell corrente.<\/li>\n
                • La Job Control consente di gestire facilmente i processi avviati dal terminale.<\/li>\n<\/ul>\n
                  103.5.3 Garantire la persistenza dei processi<\/h2>\n
                  Normalmente, quando si chiude una sessione del terminale o ci si disconnette dal sistema, tutti i processi avviati da quella sessione vengono terminati automaticamente. Questo comportamento \u00e8 corretto nella maggior parte dei casi, ma pu\u00f2 rappresentare un problema per operazioni di lunga durata, come backup, compilazioni software o script che richiedono molte ore per essere completati.<\/p>\n
                  Per evitare che un processo venga interrotto al termine della sessione \u00e8 possibile utilizzare il comando nohup<\/code> (No Hang Up<\/strong>).<\/p>\n
                  \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere il comando nohup<\/code> e comprendere che permette a un processo di continuare l’esecuzione anche dopo la chiusura del terminale o il logout dell’utente.<\/p><\/blockquote>\n
                  \n
                  Il comando nohup<\/code><\/h3>\n
                  La sintassi generale \u00e8:<\/p>\n
                  nohup comando &\r\n<\/code><\/pre>\n
                  Ad esempio:<\/p>\n
                  nohup long-running-command &\r\n<\/code><\/pre>\n
                  oppure:<\/p>\n
                  nohup backup.sh &\r\n<\/code><\/pre>\n
                  Il processo viene avviato in background e continua ad essere eseguito anche dopo la chiusura della sessione.<\/p>\n
                  \n
                  Dove viene salvato l’output?<\/h3>\n
                  Se non viene specificato alcun reindirizzamento, nohup<\/code> salva automaticamente l’output del programma nel file:<\/p>\n
                  nohup.out\r\n<\/code><\/pre>\n
                  presente nella directory corrente oppure, se non \u00e8 scrivibile, nella directory home dell’utente.<\/p>\n
                  Per salvare l’output in un file specifico \u00e8 possibile utilizzare un normale reindirizzamento:<\/p>\n
                  nohup backup.sh > backup.log 2>&1 &\r\n<\/code><\/pre>\n
                  In questo esempio:<\/p>\n
                    \n
                  • il processo continua dopo il logout;<\/li>\n
                  • l’output normale viene salvato in backup.log<\/code>;<\/li>\n
                  • anche gli eventuali messaggi di errore vengono registrati nello stesso file.<\/li>\n<\/ul>\n
                    \n
                    Quando utilizzare nohup<\/code>?<\/h3>\n
                    Il comando \u00e8 particolarmente utile per:<\/p>\n
                      \n
                    • backup di lunga durata;<\/li>\n
                    • script di manutenzione;<\/li>\n
                    • compilazione di grandi progetti software;<\/li>\n
                    • download molto lunghi;<\/li>\n
                    • qualsiasi attivit\u00e0 che deve continuare anche dopo il logout.<\/li>\n<\/ul>\n
                      \n
                      nohup<\/code> e il background<\/h3>\n
                      Nella maggior parte dei casi nohup<\/code> viene utilizzato insieme all’operatore &<\/code>.<\/p>\n
                      Ad esempio:<\/p>\n
                      nohup long-running-command &\r\n<\/code><\/pre>\n
                      Le due funzionalit\u00e0 svolgono ruoli differenti:<\/p>\n
                        \n
                      • &<\/code> avvia il processo in background;<\/li>\n
                      • nohup<\/code> impedisce che il processo venga terminato al logout.<\/li>\n<\/ul>\n
                        Utilizzati insieme consentono di eseguire processi indipendenti dalla sessione del terminale.<\/p>\n
                        \n
                        Best Practice<\/h3>\n
                        Quando utilizzi nohup<\/code>, reindirizza sempre l’output verso un file di log. In questo modo potrai verificare l’avanzamento del processo anche dopo esserti disconnesso dal sistema.<\/p>\n
                        \ud83d\udccc Da ricordare<\/strong> nohup<\/code> non sostituisce strumenti come screen<\/code> o tmux<\/code>, che consentono di riprendere una sessione interattiva. Il suo scopo \u00e8 permettere a un processo di continuare l’esecuzione dopo il logout.<\/p><\/blockquote>\n
                        \n
                        Riepilogo<\/h3>\n
                          \n
                        • nohup<\/code> permette a un processo di continuare l’esecuzione anche dopo il logout.<\/li>\n
                        • Viene normalmente utilizzato insieme all’operatore &<\/code>.<\/li>\n
                        • Se non diversamente specificato, l’output viene salvato nel file nohup.out<\/code>.<\/li>\n
                        • \u00c8 consigliabile reindirizzare l’output verso un file di log dedicato.<\/li>\n
                        • nohup<\/code> \u00e8 ideale per processi lunghi che non richiedono interazione con l’utente.<\/li>\n<\/ul>\n
                          103.5.5 Inviare segnali ai processi<\/h2>\n
                          Linux permette di controllare il comportamento dei processi inviando loro dei segnali (signals)<\/strong>. Un segnale \u00e8 un messaggio inviato dal kernel o da un altro processo per richiedere una determinata azione, come terminare un programma, interromperlo temporaneamente o ricaricarne la configurazione.<\/p>\n
                          Per inviare segnali si utilizzano principalmente i comandi kill<\/code>, pkill<\/code>, pgrep<\/code> e killall<\/code>.<\/p>\n
                          \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere il comando kill<\/code>, i segnali pi\u00f9 comuni (SIGTERM<\/code> e SIGKILL<\/code>) e sapere utilizzare pgrep<\/code>, pkill<\/code> e killall<\/code>.<\/p><\/blockquote>\n
                          \n
                          I segnali in Linux<\/h3>\n
                          Contrariamente a quanto suggerisce il nome, il comando kill<\/code> non serve esclusivamente a terminare i processi.<\/p>\n
                          Il suo vero scopo \u00e8 inviare un segnale<\/strong> a un processo.<\/p>\n
                          I segnali pi\u00f9 utilizzati sono:<\/p>\n\n\n\n\n\n\n\n\n
                          Segnale<\/th>\nNumero<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                          SIGTERM<\/code><\/td>\n15<\/td>\nRichiede la terminazione ordinata del processo (predefinito).<\/td>\n<\/tr>\n
                          SIGKILL<\/code><\/td>\n9<\/td>\nTermina immediatamente il processo senza possibilit\u00e0 di intercettare il segnale.<\/td>\n<\/tr>\n
                          SIGINT<\/code><\/td>\n2<\/td>\nInterrompe il processo (equivalente a Ctrl + C<\/strong>).<\/td>\n<\/tr>\n
                          SIGHUP<\/code><\/td>\n1<\/td>\nComunica al processo di ricaricare la configurazione o segnala la chiusura della sessione.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                          \n
                          Terminare un processo con kill<\/code><\/h3>\n
                          Per inviare il segnale predefinito (SIGTERM<\/code>) si utilizza:<\/p>\n
                          kill PID\r\n<\/code><\/pre>\n
                          oppure:<\/p>\n
                          kill -15 PID\r\n<\/code><\/pre>\n
                          Ad esempio:<\/p>\n
                          kill 24561\r\n<\/code><\/pre>\n
                          Il processo riceve una richiesta di terminazione e, se possibile, pu\u00f2 chiudersi correttamente salvando dati e liberando le risorse utilizzate.<\/p>\n
                          \n
                          Terminare forzatamente un processo<\/h3>\n
                          Se un processo non risponde al segnale SIGTERM<\/code>, \u00e8 possibile inviare il segnale SIGKILL<\/code>:<\/p>\n
                          kill -9 PID\r\n<\/code><\/pre>\n
                          Ad esempio:<\/p>\n
                          kill -9 24561\r\n<\/code><\/pre>\n
                          \u26a0\ufe0f Attenzione<\/strong> SIGKILL<\/code> termina immediatamente il processo senza permettergli di eseguire operazioni di chiusura. Utilizzalo solo quando il normale SIGTERM<\/code> non \u00e8 sufficiente.<\/p><\/blockquote>\n
                          \n
                          Ricercare processi con pgrep<\/code><\/h3>\n
                          Il comando pgrep<\/code> consente di individuare i PID dei processi in base al loro nome.<\/p>\n
                          Ad esempio:<\/p>\n
                          pgrep firefox\r\n<\/code><\/pre>\n
                          L’output conterr\u00e0 uno o pi\u00f9 PID relativi ai processi trovati.<\/p>\n
                          Questo comando \u00e8 particolarmente utile negli script Bash.<\/p>\n
                          \n
                          Terminare processi con pkill<\/code><\/h3>\n
                          Il comando pkill<\/code> combina le funzionalit\u00e0 di pgrep<\/code> e kill<\/code>, consentendo di inviare un segnale direttamente ai processi identificati dal nome.<\/p>\n
                          Ad esempio:<\/p>\n
                          pkill firefox\r\n<\/code><\/pre>\n
                          Tutti i processi chiamati firefox<\/code> riceveranno il segnale predefinito SIGTERM<\/code>.<\/p>\n
                          \n
                          Terminare tutti i processi con killall<\/code><\/h3>\n
                          Il comando killall<\/code> invia un segnale a tutte le istanze di un determinato programma.<\/p>\n
                          Esempio:<\/p>\n
                          killall firefox\r\n<\/code><\/pre>\n
                          Tutti i processi con quel nome verranno terminati.<\/p>\n
                          A differenza di kill<\/code>, non \u00e8 necessario conoscere il PID del processo.<\/p>\n
                          \n
                          Quale comando utilizzare?<\/h3>\n\n\n\n\n\n\n\n\n
                          Comando<\/th>\nUtilizzo<\/th>\n<\/tr>\n<\/thead>\n
                          kill<\/code><\/td>\nInvia un segnale a un PID specifico.<\/td>\n<\/tr>\n
                          pgrep<\/code><\/td>\nRicerca i PID dei processi in base al nome.<\/td>\n<\/tr>\n
                          pkill<\/code><\/td>\nInvia un segnale ai processi identificati dal nome.<\/td>\n<\/tr>\n
                          killall<\/code><\/td>\nInvia un segnale a tutte le istanze di un programma.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                          \ud83d\udccc Da ricordare<\/strong> Prima di utilizzare kill -9<\/code>, prova sempre il comando kill<\/code> senza specificare alcun segnale. La terminazione “gentile” tramite SIGTERM<\/code> \u00e8 la pratica consigliata e consente ai programmi di chiudersi correttamente.<\/p><\/blockquote>\n
                          \n
                          Best Practice<\/h3>\n
                          Utilizza pgrep<\/code> per individuare il PID di un processo e invia inizialmente il segnale SIGTERM<\/code> mediante kill<\/code>. Ricorri a SIGKILL<\/code> (kill -9<\/code>) solo come ultima soluzione, quando il processo non risponde ai normali segnali di terminazione.<\/p>\n
                          \n
                          Riepilogo<\/h3>\n
                            \n
                          • kill<\/code> invia un segnale a un processo identificato dal PID.<\/li>\n
                          • SIGTERM<\/code> (15) richiede una terminazione ordinata ed \u00e8 il segnale predefinito.<\/li>\n
                          • SIGKILL<\/code> (9) termina immediatamente il processo.<\/li>\n
                          • pgrep<\/code> ricerca i processi in base al nome.<\/li>\n
                          • pkill<\/code> invia segnali ai processi trovati tramite il nome.<\/li>\n
                          • killall<\/code> termina tutte le istanze di un determinato programma.<\/li>\n<\/ul>\n
                            103.5.6 Strumenti avanzati di monitoraggio<\/h2>\n
                            Oltre ai comandi tradizionali per monitorare i processi, Linux mette a disposizione strumenti che consentono di osservare continuamente lo stato del sistema oppure di mantenere attive sessioni di terminale anche dopo la disconnessione dell’utente.<\/p>\n
                            Tra questi troviamo il comando watch<\/code> e i terminal multiplexer screen<\/code> e tmux<\/code>, strumenti molto diffusi nell’amministrazione di server remoti.<\/p>\n
                            \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere lo scopo del comando watch<\/code> e sapere che screen<\/code> e tmux<\/code> permettono di mantenere sessioni di terminale persistenti.<\/p><\/blockquote>\n
                            \n
                            Monitorare un comando con watch<\/code><\/h3>\n
                            Il comando watch<\/code> esegue automaticamente un comando a intervalli regolari, aggiornandone continuamente il risultato sullo schermo.<\/p>\n
                            La sintassi generale \u00e8:<\/p>\n
                            watch comando\r\n<\/code><\/pre>\n
                            Ad esempio, per monitorare l’utilizzo della memoria:<\/p>\n
                            watch free -h\r\n<\/code><\/pre>\n
                            L’output verr\u00e0 aggiornato automaticamente ogni due secondi.<\/p>\n
                            \u00c8 possibile modificare l’intervallo di aggiornamento con l’opzione -n<\/code>.<\/p>\n
                            Ad esempio:<\/p>\n
                            watch -n 5 free -h\r\n<\/code><\/pre>\n
                            In questo caso il comando verr\u00e0 eseguito ogni cinque secondi.<\/p>\n
                            Il comando watch<\/code> \u00e8 molto utile per monitorare:<\/p>\n
                              \n
                            • l’utilizzo della memoria;<\/li>\n
                            • lo spazio disponibile sui dischi;<\/li>\n
                            • i processi attivi;<\/li>\n
                            • lo stato di file o servizi di sistema.<\/li>\n<\/ul>\n
                              \n
                              Sessioni persistenti con screen<\/code><\/h3>\n
                              screen<\/code> \u00e8 un terminal multiplexer<\/strong>, cio\u00e8 un programma che consente di creare e gestire pi\u00f9 sessioni di terminale indipendenti.<\/p>\n
                              Per avviare una nuova sessione:<\/p>\n
                              screen -S session_name\r\n<\/code><\/pre>\n
                              Una volta creata, la sessione pu\u00f2 essere scollegata (detached<\/em>) e lasciata in esecuzione anche dopo il logout.<\/p>\n
                              Successivamente \u00e8 possibile riconnettersi alla stessa sessione senza interrompere i processi in esecuzione.<\/p>\n
                              \n
                              Sessioni persistenti con tmux<\/code><\/h3>\n
                              tmux<\/code> offre funzionalit\u00e0 simili a screen<\/code> ed \u00e8 oggi molto diffuso negli ambienti Linux.<\/p>\n
                              Per creare una nuova sessione:<\/p>\n
                              tmux new -s session_name\r\n<\/code><\/pre>\n
                              Come screen<\/code>, permette di:<\/p>\n
                                \n
                              • mantenere attivi processi anche dopo la disconnessione;<\/li>\n
                              • gestire pi\u00f9 terminali all’interno della stessa finestra;<\/li>\n
                              • ricollegarsi successivamente alla sessione.<\/li>\n<\/ul>\n
                                \n
                                Quando utilizzare questi strumenti?<\/h3>\n\n\n\n\n\n\n\n
                                Strumento<\/th>\nUtilizzo principale<\/th>\n<\/tr>\n<\/thead>\n
                                watch<\/code><\/td>\nMonitora periodicamente l’output di un comando.<\/td>\n<\/tr>\n
                                screen<\/code><\/td>\nCrea sessioni di terminale persistenti.<\/td>\n<\/tr>\n
                                tmux<\/code><\/td>\nGestisce sessioni di terminale persistenti e multiple.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                \ud83d\udccc Da ricordare<\/strong> A differenza di nohup<\/code>, che mantiene in esecuzione un singolo processo dopo il logout, screen<\/code> e tmux<\/code> consentono di riprendere un’intera sessione di terminale, con tutti i programmi ancora attivi.<\/p><\/blockquote>\n
                                \n
                                Best Practice<\/h3>\n
                                Quando lavori su server remoti tramite SSH ed esegui operazioni di lunga durata, utilizza screen<\/code> o tmux<\/code>. In questo modo potrai disconnetterti e riconnetterti successivamente senza interrompere i processi in esecuzione.<\/p>\n
                                \n
                                Riepilogo<\/h3>\n
                                  \n
                                • watch<\/code> esegue periodicamente un comando e ne aggiorna automaticamente l’output.<\/li>\n
                                • L’opzione -n<\/code> permette di impostare l’intervallo di aggiornamento.<\/li>\n
                                • screen<\/code> crea sessioni di terminale persistenti.<\/li>\n
                                • tmux<\/code> offre funzionalit\u00e0 simili a screen<\/code>, consentendo di gestire pi\u00f9 terminali e sessioni persistenti.<\/li>\n
                                • Entrambi permettono di continuare il lavoro anche dopo la chiusura della connessione SSH.<\/li>\n<\/ul>\n
                                  \ud83d\udcda Riepilogo della lezione<\/h2>\n
                                  In questa lezione hai imparato come Linux gestisce i processi e come controllarne l’esecuzione dalla riga di comando. Hai scoperto la differenza tra processi eseguiti in foreground e background, come monitorare le risorse del sistema e come intervenire sui processi mediante segnali e strumenti dedicati.<\/p>\n
                                  Hai inoltre approfondito l’utilizzo della Job Control<\/strong>, dei comandi di monitoraggio e degli strumenti che consentono di mantenere attive le sessioni di lavoro anche dopo la disconnessione dal sistema.<\/p>\n
                                  Concetti principali<\/h3>\n
                                    \n
                                  • Hai compreso la differenza tra processi eseguiti in foreground<\/strong> e background<\/strong>.<\/li>\n
                                  • Hai imparato a gestire i job con jobs<\/code>, bg<\/code> e fg<\/code>.<\/li>\n
                                  • Hai utilizzato nohup<\/code> per mantenere in esecuzione un processo anche dopo il logout.<\/li>\n
                                  • Hai imparato a monitorare i processi mediante ps<\/code>, top<\/code>, uptime<\/code> e free<\/code>.<\/li>\n
                                  • Hai scoperto come inviare segnali ai processi utilizzando kill<\/code>, pgrep<\/code>, pkill<\/code> e killall<\/code>.<\/li>\n
                                  • Hai conosciuto il comando watch<\/code> e il funzionamento dei terminal multiplexer screen<\/code> e tmux<\/code>.<\/li>\n<\/ul>\n
                                    \ud83c\udfaf Obiettivo raggiunto<\/strong> Al termine di questa lezione sei in grado di creare, monitorare e gestire i processi Linux, controllarne il consumo di risorse, mantenerli in esecuzione anche dopo il logout e terminarli utilizzando gli strumenti e i segnali pi\u00f9 appropriati.<\/p><\/blockquote>\n
                                    Comandi da ricordare<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
                                    Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                    &<\/code><\/td>\nAvvia un processo in background.<\/td>\n<\/tr>\n
                                    jobs<\/code><\/td>\nVisualizza i job della shell corrente.<\/td>\n<\/tr>\n
                                    bg<\/code><\/td>\nRiprende un processo sospeso in background.<\/td>\n<\/tr>\n
                                    fg<\/code><\/td>\nRiporta un processo in foreground.<\/td>\n<\/tr>\n
                                    nohup<\/code><\/td>\nMantiene un processo in esecuzione dopo il logout.<\/td>\n<\/tr>\n
                                    ps<\/code><\/td>\nVisualizza una fotografia dei processi in esecuzione.<\/td>\n<\/tr>\n
                                    top<\/code><\/td>\nMonitora processi e risorse in tempo reale.<\/td>\n<\/tr>\n
                                    uptime<\/code><\/td>\nMostra il tempo di attivit\u00e0 e il Load Average del sistema.<\/td>\n<\/tr>\n
                                    free -h<\/code><\/td>\nVisualizza l’utilizzo della memoria RAM e della swap.<\/td>\n<\/tr>\n
                                    kill<\/code><\/td>\nInvia un segnale a un processo tramite il PID.<\/td>\n<\/tr>\n
                                    pgrep<\/code><\/td>\nRicerca processi in base al nome.<\/td>\n<\/tr>\n
                                    pkill<\/code><\/td>\nInvia segnali ai processi individuati tramite il nome.<\/td>\n<\/tr>\n
                                    killall<\/code><\/td>\nInvia un segnale a tutte le istanze di un programma.<\/td>\n<\/tr>\n
                                    watch<\/code><\/td>\nEsegue periodicamente un comando aggiornandone l’output.<\/td>\n<\/tr>\n
                                    screen<\/code><\/td>\nGestisce sessioni di terminale persistenti.<\/td>\n<\/tr>\n
                                    tmux<\/code><\/td>\nGestisce sessioni di terminale persistenti e multiple.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                    \ud83d\udca1 Preparazione all’esame LPIC-1<\/strong> Prima di proseguire assicurati di conoscere la differenza tra foreground e background, il funzionamento della Job Control, i principali comandi di monitoraggio dei processi e i segnali SIGTERM<\/code> e SIGKILL<\/code>. Questi argomenti costituiscono una parte fondamentale dell’esame LPIC-1 e dell’amministrazione quotidiana dei sistemi Linux.<\/p><\/blockquote>\n
                                    \n
                                    \u27a1\ufe0f Prossima lezione<\/h2>\n
                                    Nella prossima lezione (103.6 Modificare la priorit\u00e0 di esecuzione dei processi<\/strong>) scoprirai come Linux assegna le risorse della CPU ai processi. Imparerai a utilizzare i comandi nice<\/code> e renice<\/code> per modificare la priorit\u00e0 di esecuzione delle applicazioni e ottimizzare il comportamento del sistema.<\/p>\n
                                    \ud83d\udcd6 Materiale di approfondimento<\/strong> Consulta il PDF allegato alla lezione per esercitarti con laboratori guidati, scenari realistici e quiz di autovalutazione.<\/p><\/blockquote>\n","protected":false},"comment_status":"open","ping_status":"closed","template":"","class_list":["post-3639","lesson","type-lesson","status-publish","has-post-thumbnail","hentry"],"uagb_featured_image_src":[],"uagb_author_info":{"display_name":"Rootmail Academy","author_link":"https:\/\/rootmail.it\/en\/author\/"},"uagb_comment_info":0,"uagb_excerpt":"103.5 Creare, monitorare e terminare i processi Ogni programma in esecuzione su un sistema Linux viene gestito come un processo. Dal semplice comando eseguito nel terminale ai servizi di sistema, fino alle applicazioni in background, tutto ci\u00f2 che viene eseguito dal sistema operativo \u00e8 rappresentato da uno o pi\u00f9 processi. Linux mette a disposizione numerosi…","_links":{"self":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson\/3639","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson"}],"about":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/types\/lesson"}],"replies":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/comments?post=3639"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media\/3677"}],"wp:attachment":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media?parent=3639"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}