Linux si è evoluto molto sin dal suo inizio. È diventato il sistema operativo più utilizzato quando si tratta di server e lavoro mission-critical. Anche se non è facile capire Linux nel suo insieme, ci sono aspetti che sono fondamentali per Linux e vale la pena capirli.
In questo articolo, discuteremo di processi, thread e processi leggeri di Linux e capiremo la differenza tra loro. Verso la fine, discuteremo anche di vari stati per i processi Linux.
Processi Linux
In una forma molto semplice, il processo Linux può essere visualizzato come istanza in esecuzione di un programma. Ad esempio, basta aprire un editor di testo sulla tua macchina Linux e nascerà un processo di editor di testo.
Ecco un esempio di quando ho aperto gedit sul mio computer:
$ gedit & [1] 5560 $ ps -aef | grep gedit 1000 5560 2684 9 17:34 pts/0 00:00:00 gedit
Il primo comando (gedit &) apre la finestra di gedit mentre il secondo comando ps (ps -aef | grep gedit) controlla se esiste un processo associato. Nel risultato puoi vedere che c'è un processo associato a gedit.
I processi sono fondamentali per Linux poiché ogni singolo lavoro svolto dal sistema operativo viene svolto in termini di e dai processi. Pensa a qualsiasi cosa e vedrai che è un processo. Questo perché qualsiasi lavoro che deve essere svolto richiede risorse di sistema (che sono fornite dal kernel) ed è un processo che è visto dal kernel come un'entità a cui può fornire risorse di sistema.
I processi hanno la priorità in base al contesto del kernel che li cambia. Un processo può essere anticipato se un processo con priorità più alta è pronto per essere eseguito.
Ad esempio, se un processo è in attesa di una risorsa di sistema come del testo da un file di testo conservato su disco, il kernel può pianificare un processo con priorità più alta e tornare al processo di attesa quando i dati sono disponibili. Ciò mantiene la palla al balzo per un sistema operativo nel suo insieme e dà all'utente la sensazione che le attività vengano eseguite in parallelo.
I processi possono comunicare con altri processi utilizzando metodi di comunicazione tra processi e possono condividere dati utilizzando tecniche come la memoria condivisa.
In Linux, fork() viene utilizzato per creare nuovi processi. Questi nuovi processi sono chiamati processi figlio e ogni processo figlio inizialmente condivide tutti i segmenti come testo, stack, heap ecc. finché il figlio non tenta di apportare modifiche allo stack o all'heap. In caso di qualsiasi modifica, viene preparata una copia separata dei segmenti dello stack e dell'heap per il figlio in modo che le modifiche rimangano specifiche per il figlio. Il segmento di testo è di sola lettura, quindi sia il genitore che il figlio condividono lo stesso segmento di testo. L'articolo sulla funzione fork C spiega di più su fork().
Thread Linux vs processi leggeri
I thread in Linux non sono altro che un flusso di esecuzione del processo. Un processo contenente più flussi di esecuzione è noto come processo multi-thread.
Per un processo non multi-thread esiste solo il flusso di esecuzione che è il flusso di esecuzione principale e quindi è anche noto come processo a thread singolo. Per il kernel Linux, non esiste il concetto di thread. Ogni thread è visto dal kernel come un processo separato, ma questi processi sono in qualche modo diversi dagli altri processi normali. Spiegherò la differenza nei paragrafi seguenti.
I thread sono spesso mischiati con il termine Processi leggeri o LWP. Il motivo risale a quei tempi in cui Linux supportava i thread solo a livello di utente. Ciò significa che anche un'applicazione multi-thread è stata vista dal kernel come un unico processo. Ciò ha posto grandi sfide per la libreria che gestiva questi thread a livello di utente perché doveva occuparsi dei casi in cui l'esecuzione di un thread non ostacolava se un altro thread emetteva una chiamata di blocco.
Successivamente l'implementazione è cambiata e i processi sono stati allegati a ciascun thread in modo che il kernel potesse occuparsene. Ma, come discusso in precedenza, il kernel Linux non li vede come thread, ogni thread è visto come un processo all'interno del kernel. Questi processi sono noti come processi leggeri.
La principale differenza tra un processo leggero (LWP) e un processo normale è che le LWP condividono lo stesso spazio di indirizzi e altre risorse come file aperti ecc. Poiché alcune risorse sono condivise, questi processi sono considerati leggeri rispetto ad altri processi normali e da qui il nome processi leggeri.
Quindi, in effetti, possiamo dire che i fili e i processi leggeri sono gli stessi. È solo che thread è un termine utilizzato a livello di utente mentre processo leggero è un termine utilizzato a livello di kernel.
Dal punto di vista dell'implementazione, i thread vengono creati utilizzando le funzioni esposte dalla libreria pthread conforme a POSIX in Linux. Internamente, la funzione clone() viene utilizzata per creare un processo normale e leggero. Ciò significa che per creare un normale processo viene utilizzato fork() che chiama ulteriormente clone() con argomenti appropriati mentre per creare un thread o LWP, una funzione dalla libreria pthread chiama clone() con flag pertinenti. Quindi, la differenza principale è generata dall'utilizzo di diversi flag che possono essere passati alla funzione clone().
Maggiori informazioni su fork() e clone() nelle rispettive pagine man.
Come creare thread in Linux spiega di più sui thread.
Stati del processo Linux
Il ciclo di vita di un normale processo Linux sembra molto simile alla vita reale. I processi nascono, condividono risorse con i genitori per qualche tempo, ottengono la propria copia delle risorse quando sono pronti per apportare modifiche, attraversano vari stati a seconda della loro priorità e infine muoiono. In questa sezione verranno discussi vari stati dei processi Linux:
- RUNNING – Questo stato specifica che il processo è in esecuzione o in attesa di essere eseguito.
- INTERRUTTIBILE – Questo stato specifica che il processo è in attesa di essere interrotto poiché è in modalità di sospensione e attende che si verifichi un'azione che possa riattivare questo processo. L'azione può essere un interrupt hardware, un segnale ecc.
- UN-INTERRUPTIBLE – È proprio come lo stato INTERRUPTIBLE, l'unica differenza è che un processo in questo stato non può essere riattivato fornendo un segnale.
- STOPPED – Questo stato specifica che il processo è stato interrotto. Ciò può accadere se al processo viene inviato un segnale come SIGSTOP, SIGTTIN ecc.
- TRACED – Questo stato specifica che è in corso il debug del processo. Ogni volta che il processo viene interrotto dal debugger (per aiutare l'utente a eseguire il debug del codice), il processo entra in questo stato.
- ZOMBIE – Questo stato specifica che il processo è terminato ma è ancora in giro nella tabella dei processi del kernel perché il genitore di questo processo non ha ancora recuperato lo stato di terminazione di questo processo. Parent utilizza la famiglia di funzioni wait() per recuperare lo stato di terminazione.
- DEAD – Questo stato specifica che il processo viene terminato e la voce viene rimossa dalla tabella del processo. Questo stato viene raggiunto quando il genitore recupera con successo lo stato di terminazione come spiegato nello stato ZOMBIE.