同步模式之保护性暂停

一个线程等待另一个线程的执行结果
要点：

  • 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 Guarded Suspension
  • 如果有结果不断从一个线程到另一个线程那么可以使用消息队列
  • JDK 中，join 实现、Future 的实现，采用的就是此模式
  • 因为要等待另一方的结果，因此归类到同步模式

image.png

死锁

定位死锁

  • 检测死锁可以使用 jconsole 工具，线程tab中有个检测死锁的功能；
  • 使用 jps 定位进程 id，再用 jstack 定位死锁；

    模拟死锁

    ```java package top.simba1949;

/**

  • @author Anthony

  • @date 2020/10/26 16:48 */ public class Application { public static void main(String[] args) {

    1.  Object a = new Object();
    2.  Object b = new Object();
    4.  Thread t1 = new Thread(() ->{
    5.      synchronized (a){
    6.          System.out.println("lock a");
    7.          try {
    8.              Thread.sleep(10);
    9.              synchronized (b){
    10.                  System.out.println("lock b");
    11.              }
    12.          } catch (InterruptedException e) {
    13.              e.printStackTrace();
    14.          }
    15.      }
    16.  }, "t1");
    18.  Thread t2 = new Thread(() ->{
    19.      synchronized (b){
    20.          System.out.println("lock b");
    21.          try {
    22.              Thread.sleep(5);
    23.              synchronized (a){
    24.                  System.out.println("lock a");
    25.              }
    26.          } catch (InterruptedException e) {
    27.              e.printStackTrace();
    28.          }
    29.      }
    30.  } ,"t2");
    32.  t1.start();
    33.  t2.start();

    } } ```

    同步控制

    顺序控制

    wait&notify实现

    ```java package top.simba1949;

/**

  • @author Anthony

  • @date 2020/10/24 10:01 */ public class Application {

    static final Object lock = new Object(); /**

    • t2 是否运行过 */ static boolean t2RunBl = false;

      public static void main(String[] args) { Thread t1 = new Thread(() -> {

      1.  synchronized (lock){
      2.      while (!t2RunBl){
      3.          try {
      4.              // 如果线程2未执行，进入等待状态
      5.              lock.wait();
      6.          } catch (InterruptedException e) {
      7.              e.printStackTrace();
      8.          }
      9.      }
      10.      System.out.println("t1线程");
      11.  }

      }, “t1”);

      Thread t2 = new Thread(() -> {

      1.  try {
      2.      // 使用 sleep 可以放大控制顺序的效果
      3.      Thread.sleep(10000);
      4.  } catch (InterruptedException e) {
      5.      e.printStackTrace();
      6.  }
      8.  synchronized (lock){
      9.      System.out.println("t2线程");
      10.      t2RunBl = true;
      11.      lock.notify();
      12.  }

      }, “t2”);

      t1.start(); t2.start(); } } ```

      ReentrantLock和条件变量实现

      ```java package top.simba1949;

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

/**

  • @author Anthony

  • @date 2020/10/24 10:01 */ public class Application {

    static final ReentrantLock reentrantLock = new ReentrantLock(); static Condition condition = reentrantLock.newCondition(); /**

    • t2 是否运行过 */ static boolean t2RunBl = false;

      public static void main(String[] args) { Thread t1 = new Thread(() -> {

      1.  reentrantLock.lock();
      2.  try{
      3.      while (!t2RunBl){
      4.          try {
      5.              // 没有获取到锁的线程，进入线程休息室休息，等待唤醒，
      6.              // 唤醒后从这条语句后面开始执行
      7.              condition.await();
      8.              System.out.println("t1");
      9.          } catch (InterruptedException e) {
      10.              e.printStackTrace();
      11.          }
      12.      }
      13.  }finally {
      14.      reentrantLock.unlock();
      15.  }

      }, “t1”);

      Thread t2 = new Thread(() -> {

      1.  try {
      2.      // 使用 sleep 可以放大控制顺序的效果
      3.      Thread.sleep(10000);
      4.  } catch (InterruptedException e) {
      5.      e.printStackTrace();
      6.  }
      8.  reentrantLock.lock();
      9.  try{
      10.      System.out.println("t2");
      11.      t2RunBl = true;
      12.      condition.signal();
      13.  }finally {
      14.      reentrantLock.unlock();
      15.  }

      }, “t2”);

      t1.start(); t2.start(); } } ```

      park&unpark实现

      ```java package top.simba1949;

import java.util.concurrent.locks.LockSupport;

/**

  • @author Anthony

  • @date 2020/10/24 10:01 */ public class Application {

    public static void main(String[] args) {

    1.  Thread t1 = new Thread(() -> {
    2.      LockSupport.park();
    3.      System.out.println("t1");
    4.  }, "t1");
    5.  t1.start();
    7.  Thread t2 = new Thread(() -> {
    8.      System.out.println("t2");
    9.      LockSupport.unpark(t1);
    10.  }, "t2");
    11.  t2.start();

    }

}

  1. <a name="aCFuT"></a>
  2. ## 交替输出
  3. <a name="QoNlu"></a>
  4. ### wait&notify实现
  5. ```java
  6. package top.simba1949;
  8. /**
  9.  * 输出结果为 a——>b——>c——>a——>b——>c——>...
  10.  * 输出内容 等待标记 下一个标记
  11.  * a        1       2
  12.  * b        2       3
  13.  * c        3       1
  14.  * @author Anthony
  15.  * @date 2020/10/24 10:01
  16.  */
  17. public class Application4 {
  19.     public static void main(String[] args) {
  20.         WaitNotify waitNotify = new WaitNotify(1, 5);
  21.         new Thread(() -> waitNotify.print("a", 1, 2), "t1").start();
  22.         new Thread(() -> waitNotify.print("b", 2, 3), "t2").start();
  23.         new Thread(() -> waitNotify.print("c", 3, 1), "t3").start();
  24.     }
  26. }
  27. class WaitNotify{
  28.     // 等待标记
  29.     private int flag;
  30.     // 循环次数
  31.     private int loopNumber;
  33.     public WaitNotify(int flag, int loopNumber) {
  34.         this.flag = flag;
  35.         this.loopNumber = loopNumber;
  36.     }
  38.     /**
  39.      * 打印
  40.      * 设计思路：
  41.      * 如果当前的标记与当前线程等待的标记一致，执行打印内容，并设置当前线程的下一个标记为当前标记，并唤醒其他线程
  42.      * 如果当前的标记与当前线程等待的标记不一致，当前线程进入wait状态
  43.      * @param str
  44.      * @param waitFlag
  45.      * @param nextFlag
  46.      */
  47.     public void print(String str, int waitFlag, int nextFlag){
  48.         for (int i = 0; i < loopNumber; i++) {
  49.             synchronized (this){
  50.                 while (flag != waitFlag){
  51.                     try {
  52.                         this.wait();
  53.                     } catch (InterruptedException e) {
  54.                         e.printStackTrace();
  55.                     }
  56.                 }
  57.                 // 打印内容，设置等待标记flag
  58.                 System.out.print(str + "->");
  59.                 flag = nextFlag;
  60.                 this.notifyAll();
  61.             }
  62.         }
  63.     }
  64. }

ReentrantLock和条件变量实现

通过 ReentrantLock 对象实现

  1. package top.simba1949;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.ReentrantLock;
  6. /**
  7.  * 输出结果为 a——>b——>c——>a——>b——>c——>...
  8.  * 输出内容 等待标记 下一个标记
  9.  * a        1       2
  10.  * b        2       3
  11.  * c        3       1
  12.  * @author Anthony
  13.  * @date 2020/10/24 10:01
  14.  */
  15. public class Application6 {
  17.     public static void main(String[] args) {
  18.         WaitNotify6 waitNotify = new WaitNotify6(1, 10);
  19.         new Thread(() -> waitNotify.print("a", 1, 2), "t1").start();
  20.         new Thread(() -> waitNotify.print("b", 2, 3), "t2").start();
  21.         new Thread(() -> waitNotify.print("c", 3, 1), "t3").start();
  22.     }
  24. }
  26. class WaitNotify6 {
  27.     private final ReentrantLock reentrantLock = new ReentrantLock();
  28.     // 线程休息室
  29.     private Condition condition = reentrantLock.newCondition();
  30.     // 等待标记
  31.     private int flag;
  32.     // 循环次数
  33.     private int loopNumber;
  35.     public WaitNotify6(int flag, int loopNumber) {
  36.         this.flag = flag;
  37.         this.loopNumber = loopNumber;
  38.     }
  40.     /**
  41.      * 打印
  42.      * 设计思路：
  43.      * 如果当前的标记与当前线程等待的标记一致，执行打印内容，并设置当前线程的下一个标记为当前标记，并唤醒其他线程
  44.      * 如果当前的标记与当前线程等待的标记不一致，当前线程进入wait状态
  45.      * @param str
  46.      * @param waitFlag
  47.      * @param nextFlag
  48.      */
  49.     public void print(String str, int waitFlag, int nextFlag){
  50.         for (int i = 0; i < loopNumber; i++) {
  51.             reentrantLock.lock();
  52.             while (flag != waitFlag){
  53.                 try {
  54.                     // 当前线程进入休息室休息
  55.                     condition.await();
  56.                 } catch (InterruptedException e) {
  57.                     e.printStackTrace();
  58.                 }
  59.             }
  61.             try {
  62.                 // 打印内容，设置等待标记flag
  63.                 System.out.print(str + "->");
  64.                 flag = nextFlag;
  65.                 condition.signalAll();
  66.             }finally {
  67.                 reentrantLock.unlock();
  68.             }
  70.         }
  71.     }
  72. }

通过继承 ReentrantLock 实现——比较唤醒

  1. package top.simba1949;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.ReentrantLock;
  6. /**
  7.  * 输出结果为 a——>b——>c——>a——>b——>c——>...
  8.  * 输出内容 等待标记 下一个标记
  9.  * a        1       2
  10.  * b        2       3
  11.  * c        3       1
  12.  * @author Anthony
  13.  * @date 2020/10/24 10:01
  14.  */
  15. public class Application5 {
  17.     public static void main(String[] args) {
  18.         WaitNotify5 waitNotify = new WaitNotify5(1, 10);
  19.         new Thread(() -> waitNotify.print("a", 1, 2), "t1").start();
  20.         new Thread(() -> waitNotify.print("b", 2, 3), "t2").start();
  21.         new Thread(() -> waitNotify.print("c", 3, 1), "t3").start();
  22.     }
  24. }
  26. class WaitNotify5 extends ReentrantLock {
  27.     private static final long serialVersionUID = -5778347071247661102L;
  28.     // 等待队列
  29.     private final Condition condition = this.newCondition();
  30.     // 等待标记
  31.     private int flag;
  32.     // 循环次数
  33.     private int loopNumber;
  35.     public WaitNotify5(int flag, int loopNumber) {
  36.         this.flag = flag;
  37.         this.loopNumber = loopNumber;
  38.     }
  40.     /**
  41.      * 打印
  42.      * 设计思路：
  43.      * 如果当前的标记与当前线程等待的标记一致，执行打印内容，并设置当前线程的下一个标记为当前标记，并唤醒其他线程
  44.      * 如果当前的标记与当前线程等待的标记不一致，当前线程进入wait状态
  45.      * @param str
  46.      * @param waitFlag
  47.      * @param nextFlag
  48.      */
  49.     public void print(String str, int waitFlag, int nextFlag){
  50.         for (int i = 0; i < loopNumber; i++) {
  51.             this.lock();
  52.             while (flag != waitFlag){
  53.                 try {
  54.                     // 当前线程进入休息室休息
  55.                     condition.await();
  56.                 } catch (InterruptedException e) {
  57.                     e.printStackTrace();
  58.                 }
  59.             }
  61.             try {
  62.                 // 打印内容，设置等待标记flag
  63.                 System.out.print(str + "->");
  64.                 flag = nextFlag;
  65.                 condition.signalAll();
  66.             }finally {
  67.                 this.unlock();
  68.             }
  70.         }
  71.     }
  72. }

通过继承 ReentrantLock 实现——控制唤醒顺序

  1. package top.simba1949;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.ReentrantLock;
  6. /**
  7.  * 输出结果为 a——>b——>c——>a——>b——>c——>...
  8.  * 输出内容 等待标记 下一个标记
  9.  * a        1       2
  10.  * b        2       3
  11.  * c        3       1
  12.  * @author Anthony
  13.  * @date 2020/10/24 10:01
  14.  */
  15. public class Application9 {
  17.     public static void main(String[] args) throws InterruptedException {
  18.         WaitNotify9 waitNotify = new WaitNotify9(10);
  19.         Condition conditionA = waitNotify.newCondition();
  20.         Condition conditionB = waitNotify.newCondition();
  21.         Condition conditionC = waitNotify.newCondition();
  23.         new Thread(() -> waitNotify.print("a", conditionA, conditionB), "a").start();
  24.         new Thread(() -> waitNotify.print("b", conditionB, conditionC), "b").start();
  25.         new Thread(() -> waitNotify.print("c", conditionC, conditionA), "c").start();
  27.         // 主要 await 和 signal 方法必须在lock和unlock之间使用
  28.         waitNotify.lock();
  29.         try{
  30.             // 主线程等待数秒之后，保证线程a已经启动，并且进入休息室
  31.             Thread.sleep(1000);
  32.             // 主线程程唤醒线程 a
  33.             conditionA.signal();
  34.         }finally {
  35.             waitNotify.unlock();
  36.         }
  37.     }
  39. }
  41. class WaitNotify9 extends ReentrantLock {
  42.     private static final long serialVersionUID = 6794432110745744142L;
  43.     // 循环次数
  44.     private int loopNumber;
  46.     public WaitNotify9(int loopNumber) {
  47.         this.loopNumber = loopNumber;
  48.     }
  50.     /**
  51.      * 打印
  52.      * 设计思路：
  53.      * 首先所有线程运行时首先进入休息室condition中，控制线程唤醒顺序，通过主线程唤醒第一个线程开始即可
  54.      * @param str
  55.      * @param current
  56.      * @param next
  57.      */
  58.     public void print(String str, Condition current, Condition next){
  59.         for (int i = 0; i < loopNumber; i++) {
  60.             this.lock();
  61.             try {
  62.                 // 线程执行的时候先进入各自的休息室休息
  63.                 current.await();
  64.                 // 打印内容，设置等待标记flag
  65.                 System.out.print(str + "->");
  66.                 next.signal();
  67.             } catch (InterruptedException e) {
  68.                 e.printStackTrace();
  69.             } finally {
  70.                 this.unlock();
  71.             }
  72.         }
  73.     }
  74. }

park&unpark实现——控制唤醒顺序

  1. package top.simba1949;
  3. import java.util.concurrent.locks.LockSupport;
  5. /**
  6.  * 输出结果为 a——>b——>c——>a——>b——>c——>...
  7.  * 输出内容 等待标记 下一个标记
  8.  * a        1       2
  9.  * b        2       3
  10.  * c        3       1
  11.  * @author Anthony
  12.  * @date 2020/10/24 10:01
  13.  */
  14. public class Application8 {
  16.     static Thread ta;
  17.     static Thread tb;
  18.     static Thread tc;
  20.     public static void main(String[] args) {
  21.         WaitNotify8 waitNotify8 = new WaitNotify8(10);
  22.         ta = new Thread(() -> waitNotify8.print("a", tb), "ta");
  23.         tb = new Thread(() -> waitNotify8.print("b", tc), "tb");
  24.         tc = new Thread(() -> waitNotify8.print("c", ta), "tc");
  26.         ta.start();
  27.         tb.start();
  28.         tc.start();
  29.         // 主线程唤醒第一个线程
  30.         LockSupport.unpark(ta);
  31.     }
  33. }
  35. class WaitNotify8 {
  36.     // 循环次数
  37.     private int loopNumber;
  39.     public WaitNotify8(int loopNumber) {
  40.         this.loopNumber = loopNumber;
  41.     }
  43.     /**
  44.      * 打印
  45.      * 设计思路：
  46.      *
  47.      */
  48.     public void print(String str, Thread next){
  49.         for (int i = 0; i < loopNumber; i++) {
  50.             // 针对当前线程
  51.             LockSupport.park();
  52.             System.out.print(str + "->");
  53.             LockSupport.unpark(next);
  54.         }
  55.     }
  56. }