Deadlock: cos’è e quando si verifica in informatica

In informatica, un deadlock (letteralmente traducibile come “blocco morto” o, volendo, “impasse“) è una situazione in cui due o più processi o thread di un sistema sono bloccati o in attesa indefinitamente di risorse che sono sotto il controllo di altri processi o thread. In altre parole, si verifica quando più entità di un sistema si trovano in uno stato in cui nessuna di esse può procedere ulteriormente. Si può immaginare una situazione di deadlock come una specie di stallo alla messicana, non proprio un triello (che richiederebbe almeno tre contendenti) bensì un duello tra almeno due processi che, per contendersi una risorsa (hard disk, accesso in memoria ecc.) finiscono per bloccarsi a vicenda.

I deadlock sono problematici perché possono causare il blocco del sistema o della parte di sistema coinvolta, impedendo il progresso delle attività. Possono verificarsi in sistemi multitasking o multi-threading quando i processi o i thread competono per l’accesso a risorse condivise, come ad esempio file, memoria o dispositivi hardware.

Quando avviene un deadlock

Le condizioni necessarie affinché si verifichi un deadlock sono spesso espresse tramite quattro condizioni:

1. Mutua esclusione: Almeno una risorsa deve essere acquisibile in modo esclusivo da un processo alla volta.
2. Attesa e rilascio: Un processo deve poter acquisire una risorsa e rilasciarla quando ha finito di usarla.
3. Possesso e attesa: Un processo deve possedere almeno una risorsa mentre attende di acquisire altre risorse.
4. Non prelazione: Le risorse precedentemente acquisite da un processo non possono essere rilasciate in modo forzato da un altro processo.

Per evitare i deadlock, i sistemi operativi e i programmatori spesso utilizzano varie tecniche, come l’allocazione ordinata di risorse, il rilascio anticipato di risorse o l’uso di algoritmi di rilevamento e risoluzione dei deadlock. L’obiettivo è garantire che i processi o i thread possano concorrere in modo sicuro e che i deadlock siano prevenuti o gestiti in modo appropriato quando si verificano.

Come evitare il deadlock (C++)

Ecco un esempio molto semplice di thread in C++ che evita un deadlock utilizzando la tecnica detta “lock hierarchy” (gerarchia di blocco). Questa tecnica coinvolge l’acquisizione di più lock in un ordine specifico in modo che i thread non possano incappare in un ciclo di attesa circolare, che è una delle condizioni necessarie per un deadlock.

In questo esempio ci sono due thread, thread_function1 e thread_function2, ognuno dei quali acquisisce due mutex in un ordine specifico. Questo ordine di acquisizione dei mutex (prima mutex1 e poi mutex2 in thread_function1, e viceversa in thread_function2) impedisce la possibilità di un deadlock. Se entrambi i thread cercassero di acquisire i mutex nello stesso ordine (ad esempio, mutex1 e poi mutex2 in entrambi i thread), ci sarebbe una maggiore probabilità di deadlock.

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mutex1;
std::mutex mutex2;

void thread_function1() {
std::unique_lock<std::mutex> lock1(mutex1);
std::this_thread::sleep_for(std::chrono::milliseconds(1));

std::unique_lock<std::mutex> lock2(mutex2);

// Fai qualcosa con le risorse acquisite
std::cout << "Thread 1: Acquisite mutex1 e mutex2" << std::endl;
}

void thread_function2() {
std::unique_lock<std::mutex> lock2(mutex2);
std::this_thread::sleep_for(std::chrono::milliseconds(1));

std::unique_lock<std::mutex> lock1(mutex1);

// Fai qualcosa con le risorse acquisite
std::cout << "Thread 2: Acquisite mutex2 e mutex1" << std::endl;
}

int main() {
std::thread t1(thread_function1);
std::thread t2(thread_function2);

t1.join();
t2.join();

return 0;
}