Comment résoudre le problème de blocage des threads en Java

Comment résoudre le problème de blocage des threads en Java

Introduction :
Plusieurs threads sont largement utilisés dans les programmes Java, ce qui peut améliorer la concurrence et les performances du programme. Cependant, la programmation multithread entraîne également certains problèmes potentiels, l'un des problèmes les plus courants étant le blocage des threads. Cet article présentera le concept et les causes du blocage des threads et fournira des solutions courantes, y compris des exemples de code spécifiques.

1. Qu'est-ce que l'impasse de thread ? L'impasse de thread fait référence à un problème dans lequel deux threads ou plus détiennent les verrous requis l'un par l'autre, empêchant tous les threads de poursuivre l'exécution. Lorsqu'un blocage se produit, le programme attendra indéfiniment et ne pourra être résolu qu'en redémarrant le programme. L’impasse des threads est un problème caché qui est parfois difficile à trouver et à résoudre.

2. Causes du blocage des threads

Le blocage des threads se produit généralement dans les circonstances suivantes :

Exclusion mutuelle : plusieurs threads sont en compétition pour la même ressource, et un seul thread peut occuper la ressource en même temps. Si un thread occupe la ressource A et qu'un autre thread occupe la ressource B, et qu'ils tentent tous deux d'acquérir la ressource occupée par l'autre, un blocage peut se produire.
1. Demande et conservation : un thread contient déjà certaines ressources et continue d'occuper les ressources d'origine tout en demandant d'autres ressources, ce qui empêche les autres threads d'obtenir les ressources dont il a besoin.
2. Attente circulaire : plusieurs threads forment une dépendance circulaire, et chaque thread attend que le thread suivant libère des ressources, tombant ainsi dans une boucle infinie.

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

Évitez d'utiliser plusieurs verrous : réduire la possibilité de concurrence de ressources entre les threads est un moyen efficace de résoudre le problème de blocage. Nous pouvons essayer d'éviter que plusieurs threads ne se disputent les mêmes ressources en même temps en concevant le programme de manière appropriée. Par exemple, vous pouvez utiliser des structures de données thread-safe ou utiliser les classes de collection simultanées dans le package java.util.concurrent au lieu d'opérations synchronisées et de verrous explicites.
1. Gardez les verrous en ordre : lorsque vous utilisez plusieurs verrous, gardez l'ordre d'acquisition des verrous cohérent. Si le thread 1 doit d'abord acquérir le verrou A, puis acquérir le verrou B, et que le thread 2 doit d'abord acquérir le verrou B, puis acquérir le verrou A, un blocage peut se produire. Afin d'éviter cette situation, vous pouvez convenir que les threads acquerront les verrous dans un ordre unifié.
2. Délai d'attente : définissez le délai d'expiration du verrou. Après avoir attendu plus d'un certain temps, abandonnez la demande de verrouillage et effectuez un autre traitement. En définissant un mécanisme de délai d'attente au moment où le verrou est acquis, un blocage peut être évité.
3. Détection et récupération des blocages : des outils sont disponibles pour détecter et récupérer des blocages. Vous pouvez observer l'état du thread via le thread dump ou utiliser la classe d'outils fournie par la machine virtuelle Java pour déterminer si un blocage s'est produit. Une fois qu'un blocage se produit, l'exécution du programme peut être reprise en interrompant les threads et en libérant des ressources.

Ce qui suit est un exemple de code spécifique qui montre comment utiliser le délai d'attente de verrouillage pour résoudre le problème de blocage du thread :

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockExample {
   private Lock lockA = new ReentrantLock();
   private Lock lockB = new ReentrantLock();

   public void execute() {
      Thread thread1 = new Thread(() -> {
         lockA.lock();
         try {
            Thread.sleep(1000);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
         lockB.lock();
         System.out.println("Thread 1: Executing");
         lockA.unlock();
         lockB.unlock();
      });

      Thread thread2 = new Thread(() -> {
         lockB.lock();
         try {
            Thread.sleep(1000);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
         lockA.lock();
         System.out.println("Thread 2: Executing");
         lockB.unlock();
         lockA.unlock();
      });

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

   public static void main(String[] args) {
      DeadlockExample deadlockExample = new DeadlockExample();
      deadlockExample.execute();
   }
}

Dans le code ci-dessus, nous avons créé deux threads thread1 et thread2, et utilisé respectivement lockA et lockB comme verrou. . Nous avons ajouté une instruction sleep au processus d'exécution de chaque thread pour simuler le processus des threads traitant des tâches complexes. Lorsque vous exécutez ce code, vous constaterez qu'un blocage se produira après l'exécution du programme pendant un certain temps, empêchant le programme de poursuivre son exécution.

Afin de résoudre ce problème, nous pouvons définir un délai d'attente pour l'endroit où le verrou est acquis. Voici le code modifié :

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockExample {
   private Lock lockA = new ReentrantLock();
   private Lock lockB = new ReentrantLock();

   public void execute() {
      Thread thread1 = new Thread(() -> {
         if(lockA.tryLock()){
             try {
                Thread.sleep(1000);
             } catch (InterruptedException e) {
                e.printStackTrace();
             }
             if(lockB.tryLock()){
                System.out.println("Thread 1: Executing");
                lockB.unlock();
                lockA.unlock();
             } else {
                lockA.unlock();
                System.out.println("Thread 1 failed to get lockB");
             }
         } else {
             System.out.println("Thread 1 failed to get lockA");
         }
      });

      Thread thread2 = new Thread(() -> {
         if(lockB.tryLock()){
             try {
                Thread.sleep(1000);
             } catch (InterruptedException e) {
                e.printStackTrace();
             }
             if(lockA.tryLock()){
                System.out.println("Thread 2: Executing");
                lockA.unlock();
                lockB.unlock();
             } else {
                lockB.unlock();
                System.out.println("Thread 2 failed to get lockA");
             }
         } else {
             System.out.println("Thread 2 failed to get lockB");
         }
      });

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

   public static void main(String[] args) {
      DeadlockExample deadlockExample = new DeadlockExample();
      deadlockExample.execute();
   }
}

Dans le code modifié, nous utilisons la méthode tryLock() pour tenter d'acquérir le verrou. Si le verrou n'est pas acquis dans le délai spécifié, nous abandonnons la demande de verrou et continuons. pour exécuter d’autres tâches. En ajoutant des appels à la méthode tryLock(), nous avons réussi à éviter les blocages.

Conclusion : 

Le blocage des threads est l'un des problèmes courants dans la programmation multithread, mais grâce à une conception raisonnable et à l'ajout de solutions correspondantes, nous pouvons résoudre efficacement le problème de blocage des threads. Cet article fournit des solutions courantes, notamment éviter plusieurs verrous, maintenir les verrous en ordre, attendre les délais d'attente, ainsi que détecter et récupérer les blocages. Dans le même temps, un exemple de code spécifique est donné pour montrer comment utiliser le délai d'attente de verrouillage pour résoudre le problème de blocage des threads. Dans le développement réel, nous devons choisir la solution appropriée en fonction de la situation spécifique pour assurer le fonctionnement normal et l'optimisation des performances du programme.

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!