Java - Thread Deadlock

Bonjour à tous, futurs magiciens Java ! Aujourd'hui, nous allons plonger dans l'un des concepts les plus délicats de la programmation Java : le deadlock des threads. Ne vous inquiétez pas si cela vous paraît intimidant - à la fin de cette leçon, vous serez un détective de deadlock, capable de détecter et de résoudre ces problèmes pénibles comme un professionnel !

Qu'est-ce qu'un Thread Deadlock ?

Imaginez que vous êtes à un dîner, et que vous avez besoin à la fois de fourchette et de couteau pour manger. Vous prenez la fourchette, mais lorsque vous tends vers le couteau, votre ami l'a déjà pris. En même temps, votre ami a besoin de votre fourchette pour manger, mais vous ne la lâchez pas tant que vous n'avez pas le couteau. Vous êtes tous deux bloqués, attendant que l'autre libère ce dont vous avez besoin. Cela, mes amis, c'est un deadlock dans la vie réelle !

En Java, un deadlock se produit lorsque deux ou plusieurs threads sont bloqués à jamais, chacun attendant que l'autre libère une ressource. C'est comme un face-à-face mexicain, mais avec des threads Java au lieu de cow-boys !

Comprendre les Threads et la Synchronisation

Avant de plonger plus profondément dans les deadlocks, examinons rapidement quelques concepts clés :

Threads

Les threads sont comme de petits ouvriers dans votre programme, chacun effectuant une tâche spécifique. Ils peuvent travailler simultanément, rendant votre programme plus efficace.

Synchronisation

La synchronisation est un moyen de s'assurer que seul un thread peut accéder à une ressource partagée à la fois. C'est comme mettre un panneau "Ne pas déranger" sur la porte d'une chambre d'hôtel.

Comment les Deadlocks Se Produisent

Les deadlocks se produisent généralement lorsque quatre conditions (nommées conditions de Coffman) sont réunies :

Exclusion mutuelle : Au moins une ressource doit être détenue dans un mode non partageable.
Tenir et Attendre : Un thread doit détenir au moins une ressource tout en attendant d'acquérir des ressources supplémentaires détenues par d'autres threads.
Pas de Préemption : Les ressources ne peuvent pas être arrachées à un thread par la force ; elles doivent être libérées de manière volontaire.
Attente Circulaire : Une chaîne circulaire de deux ou plusieurs threads, chacun attendant une ressource détenue par le thread suivant dans la chaîne.

Exemple : Démonstration d'une Situation de Deadlock

Regardons un exemple classique d'une situation de deadlock. Nous allons créer deux ressources (représentées par des Objets) et deux threads qui tentent d'acquérir ces ressources dans un ordre différent.

public class DeadlockExample {
private static Object resource1 = new Object();
private static Object resource2 = new Object();

public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 1 : Tenant Ressource 1...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
System.out.println("Thread 1 : En attente de Ressource 2...");
synchronized (resource2) {
System.out.println("Thread 1 : Tenant Ressource 1 et Ressource 2");
}
}
});

Thread thread2 = new Thread(() -> {
synchronized (resource2) {
System.out.println("Thread 2 : Tenant Ressource 2...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
System.out.println("Thread 2 : En attente de Ressource 1...");
synchronized (resource1) {
System.out.println("Thread 2 : Tenant Ressource 2 et Ressource 1");
}
}
});

thread1.start();
thread2.start();
}
}

Analysons cela :

Nous créons deux instances Object, resource1 et resource2, qui représentent nos ressources partagées.
Nous créons deux threads :

thread1 tente d'acquérir resource1 en premier, puis resource2.
thread2 tente d'acquérir resource2 en premier, puis resource1.

Les deux threads utilisent le mot-clé synchronized pour verrouiller les ressources.
Nous ajoutons une petite temporisation (Thread.sleep(100)) pour augmenter la probabilité d'un deadlock.

Lorsque vous exécutez ce code, il est probable de conduire à un deadlock. Le Thread 1 va acquérir resource1 et attendre resource2, tandis que le Thread 2 va acquérir resource2 et attendre resource1. Aucun thread ne peut procéder, entraînant un deadlock.

Exemple de Solution de Deadlock

Maintenant que nous avons vu comment un deadlock peut se produire, examinons comment nous pouvons le prévenir. Une solution simple consiste à acquérir toujours les ressources dans le même ordre pour tous les threads.

public class DeadlockSolutionExample {
private static Object resource1 = new Object();
private static Object resource2 = new Object();

public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 1 : Tenant Ressource 1...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
synchronized (resource2) {
System.out.println("Thread 1 : Tenant Ressource 1 et Ressource 2");
}
}
});

Thread thread2 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 2 : Tenant Ressource 1...");
try { Thread.sleep(100); } catch (InterruptedException e) {}
synchronized (resource2) {
System.out.println("Thread 2 : Tenant Ressource 1 et Ressource 2");
}
}
});

thread1.start();
thread2.start();
}
}

Dans cette solution :

Les deux threads acquirent maintenant resource1 en premier, puis resource2.
Cela garantit qu'il y a un ordre cohérent d'acquisition des ressources, empêchant la condition d'attente circulaire.

Meilleures Pratiques pour Éviter les Deadlocks

Acquérez toujours les verrous dans le même ordre : Comme nous l'avons vu dans notre exemple de solution, cela empêche l'attente circulaire.
Évitez les verrous imbriqués : Essayez de minimiser le nombre de blocs synchronisés.
Utilisez tryLock() avec un délai : Au lieu d'attendre indéfiniment, utilisez tryLock() avec un délai pour tenter d'acquérir un verrou pendant une période de temps spécifique.
Évitez de détenir des verrous pendant de longues périodes : Libérez les verrous dès que vous avez terminé avec la ressource partagée.

Conclusion

Félicitations ! Vous avez juste déverrouillé les mystères des deadlocks des threads Java. Rappelez-vous, écrire des programmes multi-threadés est comme chorégraphier une danse complexe - cela nécessite un planning et une coordination minutieux pour s'assurer que tous les danseurs (threads) se déplacent en douceur sans se marcher sur les orteils (ou verrouiller les ressources de l'autre).

Au fil de votre parcours Java, gardez ces concepts à l'esprit, et vous serez bien équipé pour écrire des programmes multi-threadés efficaces et sans deadlock. Bon codage, et que vos threads soient toujours en harmonie !

Méthode	Description
`synchronized`	Mot-clé utilisé pour créer des blocs ou des méthodes synchronisés
`Object.wait()`	Fait attendre le thread en cours jusqu'à ce qu'un autre thread invoque `notify()` ou `notifyAll()`
`Object.notify()`	Réveille un seul thread qui attend sur ce objet
`Object.notifyAll()`	Réveille tous les threads qui attendent sur ce objet
`Thread.sleep(long millis)`	Fait dormir le thread en cours d'exécution pour le nombre spécifié de millisecondes
`Lock.tryLock()`	Acquiert le verrou uniquement s'il est libre au moment de l'appel
`Lock.tryLock(long time, TimeUnit unit)`	Acquiert le verrou s'il est libre dans le délai donné
`ReentrantLock.lock()`	Acquiert le verrou
`ReentrantLock.unlock()`	Libère le verrou

Rappelez-vous, ces méthodes sont des outils puissants dans votre kit de multi-threading. Utilisez-les sagement, et vous créerez des applications Java robustes et efficaces en un rien de temps !

Credits: Image by storyset

Tutoriel précédent:

Java - Communication inter-thread

Tutoriel suivant:

Java - Interruption d'un Thread