Comment résoudre l'exception de blocage des threads Java (ThreadDeadlockException)

Comment résoudre l'exception de blocage de thread Java (ThreadDeadlockException)

Introduction :
Le multithreading est l'une des fonctionnalités couramment utilisées dans la programmation Java, mais dans un environnement multithread, des exceptions de blocage de thread peuvent survenir, c'est-à-dire entre les threads Les deux parties attendent que l'autre libère des ressources et ne peuvent pas continuer l'exécution. Cet article abordera les causes des exceptions de blocage de thread et fournira des méthodes courantes et des exemples de codes pour résoudre les blocages de thread.

1. Causes des exceptions de blocage de thread
Les blocages de thread sont généralement causés par les raisons suivantes :

1. Conditions d'exclusion mutuelle : les blocages se produisent en raison de threads en compétition pour les ressources partagées.
2. Conditions de demande et de conservation : les threads détiennent certaines ressources et demandent des ressources à d'autres threads, mais conservent les ressources qu'ils ont obtenues, se faisant attendre mutuellement.
3. Condition de non-privation : Les ressources détenues par un thread ne peuvent pas être privées par d'autres threads et ne peuvent être libérées que par elles-mêmes.
4. Condition d'attente de boucle : les threads forment une relation d'attente de boucle pour les ressources.

2. Méthodes pour résoudre les blocages de threads

1. Évitez d'utiliser trop de blocs de synchronisation :
   Des blocs de synchronisation excessifs augmenteront la probabilité de blocage, car les threads doivent attendre que d'autres threads libèrent le verrou avant de pouvoir continuer l'exécution. Vous pouvez minimiser le nombre de blocs de synchronisation ou utiliser des verrous plus fins pour réduire la probabilité de conflit de ressources entre les threads.
2. Évitez l'attente circulaire :
   Essayez d'éviter la formation d'une relation d'attente circulaire entre les threads pour les ressources. Vous pouvez utiliser l'ordre des ressources pour éviter l'attente circulaire, comme la numérotation des ressources et l'obligation pour les threads d'obtenir les ressources dans un ordre numérique.
3. Utilisez des verrous temporisés :
   Les verrous temporisés sont un mécanisme qui augmente le temps d'attente lors de la demande de ressources. Si le temps d'attente est trop long, vous pouvez abandonner la demande de ressources en cours, libérer les ressources acquises et réessayer d'acquérir les ressources.
4. Utiliser l'objet Lock :
   Java fournit l'interface Lock, qui est plus flexible que les blocs synchronisés. Vous pouvez essayer d'acquérir le verrou via la méthode tryLock() au lieu d'attendre indéfiniment. Si l'acquisition du verrou échoue, vous pouvez choisir d'autres opérations pour éviter un blocage.
5. Évitez les verrous imbriqués :
   Si un thread détient un verrou tout en essayant d'acquérir un autre verrou, et qu'un autre thread détient un autre verrou tout en essayant d'acquérir le premier verrou, il en résultera un blocage. Par conséquent, vous devez éviter de détenir un verrou tout en essayant d’en acquérir d’autres.

3. Exemple de code d'exception de blocage de thread
Ce qui suit est un exemple de code simple qui montre l'exception de blocage de thread et comment la résoudre.

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

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Holding resource 1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource2) {
                    System.out.println("Thread 1: Holding resource 1 and 2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Holding resource 2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource1) {
                    System.out.println("Thread 2: Holding resource 2 and 1");
                }
            }
        });

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

Dans cet exemple de code, deux threads détiennent respectivement deux ressources, ressource1 et ressource2, et tentent d'obtenir une autre ressource. Si deux threads s'exécutent en même temps, une exception de blocage de thread se produira car chaque thread attend que l'autre libère des ressources.

Pour résoudre ce problème, nous pouvons ajuster l'ordre dans lequel les threads obtiennent les ressources pour garantir que les threads obtiennent les ressources dans le même ordre. Par exemple, nous pouvons modifier l'ordre d'acquisition du thread 2 pour obtenir d'abord la ressource 1 puis la ressource 2. En ajustant l’ordre dans lequel les ressources sont obtenues, le problème de l’impasse peut être résolu.

Conclusion : 
L'exception de blocage de thread est un problème courant dans la programmation multithread, mais elle peut être résolue en évitant trop de blocs de synchronisation, en évitant l'attente de boucle, en utilisant des verrous temporisés et en utilisant des objets Lock. Lors de l'écriture de code multithread, vous devez faire attention aux méthodes ci-dessus pour éviter les problèmes causés par un blocage de thread.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!