Exemple Java - Blocage et solution

Un blocage est une situation dans laquelle plusieurs threads sont bloqués en même temps, l'un ou l'ensemble d'entre eux attendant la libération d'une ressource. Le thread étant bloqué indéfiniment, le programme ne peut pas se terminer correctement.

Quatre conditions nécessaires à l'impasse Java :

1> Utilisation mutuellement exclusive, c'est-à-dire que lorsqu'une ressource est utilisée (occupée) par un thread, les autres threads ne peuvent pas l'utiliser

2> Non préemptif. Les demandeurs de ressources ne peuvent pas saisir de force les ressources des occupants des ressources. Les ressources ne peuvent être libérées activement que par les occupants des ressources.

3> Demander et maintenir, c'est-à-dire lorsque le demandeur de ressources demande d'autres ressources tout en maintenant les camarades dans les ressources d'origine.

4> Boucle d'attente, c'est-à-dire qu'il y a une file d'attente : P1 occupe les ressources de P2, P2 occupe les ressources de P3, et P3 occupe les ressources de P1. Cela crée une boucle d'attente.

Lorsque les quatre conditions ci-dessus sont vraies, une impasse se forme. Bien entendu, en cas de blocage, si l’une des conditions ci-dessus n’est pas respectée, le blocage disparaîtra. Utilisons du code Java pour simuler l'apparition d'un blocage.

Les moyens de résoudre le problème de blocage sont les suivants : l'un consiste à utiliser la synchronisation et l'autre à utiliser l'implémentation du verrouillage explicite Lock.

Si les verrous sont utilisés de manière incorrecte et que plusieurs objets sont verrouillés en même temps, une situation de blocage se produira, comme suit :

/*
 author by w3cschool.cc
 LockTest.java
 */import java.util.Date;public class LockTest {
   public static String obj1 = "obj1";
   public static String obj2 = "obj2";
   public static void main(String[] args) {
      LockA la = new LockA();
      new Thread(la).start();
      LockB lb = new LockB();
      new Thread(lb).start();
   }}class LockA implements Runnable{
   public void run() {
      try {
         System.out.println(new Date().toString() + " LockA 开始执行");
         while(true){
            synchronized (LockTest.obj1) {
               System.out.println(new Date().toString() + " LockA 锁住 obj1");
               Thread.sleep(3000); // 此处等待是给B能锁住机会
               synchronized (LockTest.obj2) {
                  System.out.println(new Date().toString() + " LockA 锁住 obj2");
                  Thread.sleep(60 * 1000); // 为测试，占用了就不放
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }}class LockB implements Runnable{
   public void run() {
      try {
         System.out.println(new Date().toString() + " LockB 开始执行");
         while(true){
            synchronized (LockTest.obj2) {
               System.out.println(new Date().toString() + " LockB 锁住 obj2");
               Thread.sleep(3000); // 此处等待是给A能锁住机会
               synchronized (LockTest.obj1) {
                  System.out.println(new Date().toString() + " LockB 锁住 obj1");
                  Thread.sleep(60 * 1000); // 为测试，占用了就不放
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }}

Le résultat de sortie du code ci-dessus est :

Tue May 05 10:51:06 CST 2015 LockB 开始执行
Tue May 05 10:51:06 CST 2015 LockA 开始执行
Tue May 05 10:51:06 CST 2015 LockB 锁住 obj2
Tue May 05 10:51:06 CST 2015 LockA 锁住 obj1

Une impasse se produit à ce moment.

Afin de résoudre ce problème, nous n'utilisons pas de déverrouillage explicite, nous utilisons le contrôle sémaphore.

Le sémaphore peut contrôler le nombre de threads pouvant accéder à la ressource. Nous précisons ici qu'il n'est accessible que par un seul thread, ce qui est similaire au verrouillage. Le sémaphore peut spécifier le délai d'attente pour l'acquisition, et nous pouvons effectuer un traitement supplémentaire en fonction de ce délai d'attente.

Si vous ne parvenez pas à l'obtenir, vous pouvez généralement réessayer, ou spécifier le nombre de tentatives, ou vous pouvez quitter immédiatement.

Jetons un coup d'œil au code suivant :

/*
 author by w3cschool.cc
 UnLockTest.java
 */import java.util.Date;import java.util.concurrent.Semaphore;import java.util.concurrent.TimeUnit;public class UnLockTest {
   public static String obj1 = "obj1";
   public static final Semaphore a1 = new Semaphore(1);
   public static String obj2 = "obj2";
   public static final Semaphore a2 = new Semaphore(1);

   public static void main(String[] args) {
      LockAa la = new LockAa();
      new Thread(la).start();
      LockBb lb = new LockBb();
      new Thread(lb).start();
   }}class LockAa implements Runnable {
   public void run() {
      try {
         System.out.println(new Date().toString() + " LockA 开始执行");
         while (true) {
            if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
               System.out.println(new Date().toString() + " LockA 锁住 obj1");
               if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
                  System.out.println(new Date().toString() + " LockA 锁住 obj2");
                  Thread.sleep(60 * 1000); // do something
               }else{
                  System.out.println(new Date().toString() + "LockA 锁 obj2 失败");
               }
            }else{
               System.out.println(new Date().toString() + "LockA 锁 obj1 失败");
            }
            UnLockTest.a1.release(); // 释放
            UnLockTest.a2.release();
            Thread.sleep(1000); // 马上进行尝试，现实情况下do something是不确定的
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }}class LockBb implements Runnable {
   public void run() {
      try {
         System.out.println(new Date().toString() + " LockB 开始执行");
         while (true) {
            if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
               System.out.println(new Date().toString() + " LockB 锁住 obj2");
               if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
                  System.out.println(new Date().toString() + " LockB 锁住 obj1");
                  Thread.sleep(60 * 1000); // do something
               }else{
                  System.out.println(new Date().toString() + "LockB 锁 obj1 失败");
               }
            }else{
               System.out.println(new Date().toString() + "LockB 锁 obj2 失败");
            }
            UnLockTest.a1.release(); // 释放
            UnLockTest.a2.release();
            Thread.sleep(10 * 1000); // 这里只是为了演示，所以tryAcquire只用1秒，而且B要给A让出能执行的时间，否则两个永远是死锁
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }}

La structure de sortie de l'exemple de code ci-dessus est :

Tue May 05 10:59:13 CST 2015 LockA 开始执行
Tue May 05 10:59:13 CST 2015 LockB 开始执行
Tue May 05 10:59:13 CST 2015 LockB 锁住 obj2
Tue May 05 10:59:13 CST 2015 LockA 锁住 obj1
Tue May 05 10:59:14 CST 2015LockB 锁 obj1 失败
Tue May 05 10:59:14 CST 2015LockA 锁 obj2 失败
Tue May 05 10:59:15 CST 2015 LockA 锁住 obj1
Tue May 05 10:59:15 CST 2015 LockA 锁住 obj2

Ce qui précède est le contenu du Exemple Java - blocage et solution, Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !