Sistemi Operativi - 04: Thread

Un processo è una sequenza di istruzioni eseguite da un singolo thread.

I thread sono una soluzione per dare più efficienza allo scambio di dati tra processi. Consentono a due o più processi di condividere lo stesso spazio di indirizzamento, ovvero codice e dati, senza dover ricorrere a meccanismi espliciti di condivisione o file.

Un thread è un filo di computazione che contiene le istruzioni eseguite da un processo.

I thread velocizzano il context switch. Il context switch è il passaggio di esecuzione da un processo all'altro. Con i thread, questa operazione diventa più rapida perché non è necessario cambiare lo spazio di indirizzamento.

Un processo monofilamento ha un solo thread, eseguendo un'unica sequenza di istruzioni.

I thread riducono i miss cache. La cache è un'area di memoria veloce che memorizza dati utilizzati di recente. Quando un processo cambia, la CPU deve caricare i dati necessari nella cache, causando spesso miss cache (dati non trovati). Con thread che condividono dati, si riducono i miss cache.

I thread sono utili per gestire compiti paralleli. Un'applicazione può usare thread per eseguire diverse attività in modo simultaneo, come ricevere input utente, elaborare un file e visualizzare l'output.

I processi monofilamento non possono accedere allo spazio di indirizzamento logico di altri processi.

I thread sono utili per gestire attività reattive. Se una parte del codice è bloccata in un'operazione lunga, i thread permettono ad altre parti del programma di continuare a lavorare.

I processi monofilamento possono eseguire lo stesso codice, ma in spazi di indirizzamento separati, con dati diversi.

Un processo multi-thread è composto da più thread, chiamati peer thread.

I thread sono utili per migliorare le prestazioni. In generale, i thread possono migliorare le prestazioni delle applicazioni dividendo il lavoro in compiti più piccoli che possono essere eseguiti in parallelo.

I thread offrono un modo per implementare il multitasking. È un'estensione del concetto di processo, ma con la chiave distintiva che i thread condividono lo stesso spazio di indirizzamento, il che implica che condividono le risorse del processo come memoria e file.

Ogni thread in un processo multi-thread ha il suo stato di computazione (program counter, registri, stack).

I peer thread in un processo multi-thread condividono il codice e le aree dati.

I processi multi-thread possono specificare quale thread esegue quale parte del codice, simile alla fork.

Il passaggio da un thread all'altro all'interno dello stesso processo.

È il processo di salvataggio e ripristino dello stato di un thread quando viene sospeso o ripreso.

Il contesto di un thread comprende: Program Counter, registri della CPU e stack. Il codice e i dati dell'applicazione sono condivisi tra tutti i thread.

I thread all'interno di uno stesso processo condividono lo stesso spazio di indirizzamento, ovvero hanno accesso agli stessi dati e codice.

Il context switch tra processi è molto più pesante rispetto al context switch tra thread dello stesso processo.

Heavy-weight process (HWP)

Light-weight process (LWP)

I context switch generano più cache misses tra processi rispetto a tra thread. Questo perché i processi hanno spazi di indirizzamento separati, mentre i thread condividono lo stesso spazio.

Il costo computazionale del context switch tra thread è relativamente basso.

È un processo che consente a più thread di eseguire codice contemporaneamente su un singolo processore, alternando rapidamente tra i thread.

Un cambio di contesto tra due processi è un'operazione costosa che rallenta l'esecuzione, soprattutto a causa dei miss cache che si verificano quando un processo viene caricato in memoria.

Un'architettura multi-core è costituita da più unità di elaborazione (core) che possono eseguire processi in parallelo, migliorando le prestazioni.

Un task multi-threaded può eseguire diverse attività contemporaneamente grazie a più thread che lavorano in parallelo.

Un core superscalare è in grado di eseguire più istruzioni in parallelo, sfruttando diverse unità funzionali (ALU, unità floating point) per accelerare l'esecuzione.

Esistono dipendenze tra le istruzioni di un programma, cosa che limita l'esecuzione parallela degli istruzioni perché alcune istruzioni devono essere eseguite in sequenza, ad esempio quando un'istruzione dipende dal risultato di un'altra.

Un compito multi-threaded è un processo che può eseguire più flussi di esecuzione contemporaneamente. Ogni flusso di esecuzione è rappresentato da un thread, che è un'unità di esecuzione leggera.

I thread vengono creati tramite specifiche chiamate di sistema come 'clone' in Linux e 'CreateThread' in Windows, analogamente al modo in cui i processi vengono creati con 'fork' ed 'exec'.

I thread possono condividere i dati tra loro all'interno dello stesso processo. Questo significa che possono accedere agli stessi dati e risorse, il che può essere utile per migliorare l'efficienza.

Per evitare conflitti e mantenere l'ordine durante l'accesso ai dati condivisi, è necessario utilizzare meccanismi di sincronizzazione tra i thread, come i semafori.

Il sistema operativo gestisce i thread a livello di kernel, memorizzando le informazioni su processi e thread in strutture dati. In questo modo il sistema operativo può passare da un thread all'altro in modo efficiente.

Quando un thread termina il suo quantum di tempo o si blocca volontariamente, il sistema operativo sceglie quale thread eseguire successivamente: un altro thread dello stesso compito, un thread di un altro compito o un processo normale.

I thread sono più efficienti dei processi, perché richiedono meno risorse per essere creati e il passaggio di contesto tra di loro è più veloce.

Poiché i thread possono condividere dati ed eseguire in parallelo, sono ideali per i sistemi multi-core, dove ogni nucleo può elaborare un thread contemporaneamente.

In un sistema single-core, i thread di un compito vengono eseguiti in modo sequenziale, alternandosi sul singolo nucleo. Nonostante questo, il passaggio di contesto tra thread è comunque più efficiente rispetto al passaggio di contesto tra processi.

Il passaggio di contesto tra thread è più efficiente perché i thread condividono lo spazio di indirizzamento del processo e non richiedono una completa riorganizzazione della memoria.