1. 固定运行顺序

比如，必须先 2 后 1 打印

1.1 wait notify 版

  1. @Slf4j(topic = "c.Test25")
  2. public class Test25 {
  3.     // 用来同步的对象
  4.     static final Object lock = new Object();
  5.     // 表示 t2 是否运行过
  6.     static boolean t2runned = false;
  8.     public static void main(String[] args) {
  9.         Thread t1 = new Thread(() -> {
  10.             synchronized (lock) {
  11.                 // 等待t2线程运行
  12.                 while (!t2runned) {
  13.                     try {
  14.                         // t1 先等一会
  15.                         lock.wait();
  16.                     } catch (InterruptedException e) {
  17.                         e.printStackTrace();
  18.                     }
  19.                 }
  20.                 log.debug("1");
  21.             }
  22.         }, "t1");
  25.         Thread t2 = new Thread(() -> {
  26.             synchronized (lock) {
  27.                 log.debug("2");
  28.                 t2runned = true;
  29.                 lock.notify();
  30.             }
  31.         }, "t2");
  33.         t1.start();
  34.         t2.start();
  35.     }
  36. }

输出

  1. 16:41:58.698 c.Test25 [t2] - 2
  2. 16:41:58.699 c.Test25 [t1] - 1

1.2 Park Unpark 版

可以看到，实现上很麻烦：
首先，需要保证先 wait 再 notify，否则 wait 线程永远得不到唤醒。因此使用了『运行标记』来判断该不该 wait
第二，如果有些干扰线程错误地 notify 了 wait 线程，条件不满足时还要重新等待，使用了 while 循环来解决此问题
最后，唤醒对象上的 wait 线程需要使用 notifyAll，因为『同步对象』上的等待线程可能不止一个
可以使用 LockSupport 类的 park 和 unpark 来简化上面的题目：

  1. @Slf4j(topic = "c.Test26")
  2. public class Test26 {
  3.     public static void main(String[] args) {
  5.         Thread t1 = new Thread(() -> {
  6.             // 当没有『许可』时，当前线程暂停运行；
  7.             // 有『许可』时，用掉这个『许可』，当前线程恢复运行
  8.             LockSupport.park();
  9.             log.debug("1");
  10.         }, "t1");
  11.         t1.start();
  13.         new Thread(() -> {
  14.             log.debug("2");
  15.             // 给线程 t1 发放『许可』（多次连续调用 unpark 只会发放一个『许可』）
  16.             LockSupport.unpark(t1);
  17.         },"t2").start();
  18.     }
  19. }

park 和 unpark 方法比较灵活，他俩谁先调用，谁后调用无所谓。并且是以线程为单位进行『暂停』和『恢复』， 不需要『同步对象』和『运行标记』
输出

  1. 16:41:58.698 c.Test26 [t2] - 2
  2. 16:41:58.699 c.Test26 [t1] - 1

2. 交替输出

线程 1 输出 a 3 次，线程 2 输出 b 3 次，线程 3 输出 c 3 次。现在要求输出 abcabcabc 怎么实现

2.1 wait notify 版

  1. public class ExchangePrintTest {
  2.     public static void main(String[] args) {
  3.         WaitNotify waitNotify = new WaitNotify(1,3);
  4.         new Thread(()->{
  5.             waitNotify.print("a",1,2);
  6.         }).start();
  7.         new Thread(()->{
  8.             waitNotify.print("b",2,3);
  9.         }).start();
  10.         new Thread(()->{
  11.             waitNotify.print("c",3,1);
  12.         }).start();
  13.     }
  14. }
  16. class WaitNotify {
  17.     /**
  18.      * 等待标记
  19.      */
  20.     private int flag;
  21.     /**
  22.      * 循环次数
  23.      */
  24.     private final int next;
  26.     public WaitNotify(int flag, int next) {
  27.         this.flag = flag;
  28.         this.next = next;
  29.     }
  31.     /**
  32.      * 打印
  33.      * @param str 打印字符串
  34.      * @param waitFlag 等待标记
  35.      * @param nextFlag 下一个标记
  36.      */
  37.     public void print(String str, int waitFlag, int nextFlag){
  38.         for (int i = 0; i < next; i++) {
  39.             synchronized (this) {
  40.                 // 当前标记不等于下一步标记
  41.                 while (this.flag != waitFlag) {
  42.                     try {
  43.                         // 该线程等待
  44.                         this.wait();
  45.                     } catch (InterruptedException e) {
  46.                         e.printStackTrace();
  47.                     }
  48.                 }
  49.                 System.out.print(str);
  50.                 flag = nextFlag;
  51.                 // 所有线程唤醒
  52.                 this.notifyAll();
  53.             }
  54.         }
  55.     }
  56. }
  1. abcabcabc

2.2 Lock 条件变量版

和上面的逻辑是一样的，只是将标识符改为Condition（条件变量），然后使用了Lock锁。

  1. public class ExchangePrintLockTest {
  2.     public static void main(String[] args) {
  3.         AwaitSignal awaitSignal = new AwaitSignal(3);
  4.         Condition a1 = awaitSignal.newCondition();
  5.         Condition a2 = awaitSignal.newCondition();
  6.         Condition a3 = awaitSignal.newCondition();
  7.         new Thread(() -> {
  8.             awaitSignal.print("a", a1, a2);
  9.         }).start();
  10.         new Thread(() -> {
  11.             awaitSignal.print("b", a2, a3);
  12.         }).start();
  13.         new Thread(() -> {
  14.             awaitSignal.print("c", a3, a1);
  15.         }).start();
  17.         // 因为前面的锁，都在睡眠，必须先唤醒a1线程
  18.         awaitSignal.lock();
  19.         try {
  20.             Thread.sleep(1000);
  21.             System.out.println("开始...");
  22.             a1.signal();
  23.         } catch (InterruptedException e) {
  24.             e.printStackTrace();
  25.         }finally {
  26.             awaitSignal.unlock();
  27.         }
  28.     }
  29. }
  31. class AwaitSignal extends ReentrantLock {
  33.     private final int loopNumber;
  35.     public AwaitSignal(int loopNumber) {
  36.         this.loopNumber = loopNumber;
  37.     }
  39.     public void print(String str, Condition current, Condition next) {
  40.         for (int i = 0; i < loopNumber; i++) {
  41.             lock();
  42.             try {
  43.                 current.await();
  44.                 System.out.print(str);
  45.                 next.signal();
  46.             } catch (InterruptedException e) {
  47.                 e.printStackTrace();
  48.             } finally {
  49.                 unlock();
  50.             }
  52.         }
  53.     }
  55. }
  1. 开始...
  2. abcabcabc

进阶写法

  1. public class ExchangePrintLockTestV2 {
  2.     public static void main(String[] args) {
  3.         AwaitSignal2 as = new AwaitSignal2(3);
  4.         as.start(new Thread(() -> {
  5.             as.print("a");
  6.         }), new Thread(() -> {
  7.             as.print("b");
  8.         }), new Thread(() -> {
  9.             as.print("c");
  10.         }), new Thread(() -> {
  11.             as.print("d");
  12.         }));
  13.     }
  14. }
  16. class AwaitSignal2 extends ReentrantLock {
  17.     private final int loopNumber;
  18.     private Map<Thread, Condition[]> map =new ConcurrentHashMap<>();
  20.     public AwaitSignal2(int loopNumber) {
  21.         this.loopNumber = loopNumber;
  22.     }
  24.     public void start(Thread... threads) {
  25.         Condition[] temp = new Condition[threads.length];
  26.         int threadsLength = threads.length;
  27.         // 创建线程数的标记
  28.         for (int i = 0; i < threadsLength; i++) {
  29.             temp[i] = this.newCondition();
  30.         }
  31.         // 必须把前面的线程组全部都加入了，才能进行获取线程组中的标记
  32.         for (int i = 0; i < threadsLength; i++) {
  33.             // 条件标记
  34.             Condition current = temp[i];
  35.             // 下一个标记
  36.             Condition next;
  37.             // 2、3、1
  38.             if (i == threadsLength -1){
  39.                 next = temp[0];
  40.             } else {
  41.                 next = temp[i + 1];
  42.             }
  43.             // 对应的线程拥有的标记
  44.             map.put(threads[i], new Condition[]{current, next});
  45.         }
  46.         // 启动每个线程
  47.         for (Thread thread : map.keySet()) {
  48.             thread.start();
  49.         }
  50.         try {
  51.             Thread.sleep(500);
  52.         } catch (InterruptedException e) {
  53.             e.printStackTrace();
  54.         }
  55.         // 这里的代码，也是要先唤醒第一个线程，否则进入await就会一直睡眠
  56.         this.lock();
  57.         try {
  58.             // 唤醒第一个线程
  59.             map.get(threads[0])[0].signal();
  60.         }finally {
  61.             this.unlock();
  62.         }
  64.     }
  66.     public void print(String str){
  67.         for (int i = 0; i < loopNumber; i++) {
  68.             this.lock();
  69.             try {
  70.                 Condition[] conditions = map.get(Thread.currentThread());
  71.                 conditions[0].await();
  72.                 System.out.print(str);
  73.                 conditions[1].signal();
  74.             } catch (InterruptedException e) {
  75.                 e.printStackTrace();
  76.             } finally {
  77.                 this.unlock();
  78.             }
  79.         }
  80.     }
  82. }

2.3 Park Unpark 版

  1. public class Test31 {
  3.     static Thread t1;
  4.     static Thread t2;
  5.     static Thread t3;
  6.     public static void main(String[] args) {
  7.         ParkUnpark pu = new ParkUnpark(5);
  8.         t1 = new Thread(() -> {
  9.             pu.print("a", t2);
  10.         });
  11.         t2 = new Thread(() -> {
  12.             pu.print("b", t3);
  13.         });
  14.         t3 = new Thread(() -> {
  15.             pu.print("c", t1);
  16.         });
  17.         t1.start();
  18.         t2.start();
  19.         t3.start();
  21.         LockSupport.unpark(t1);
  22.     }
  23. }
  25. class ParkUnpark {
  26.     public void print(String str, Thread next) {
  27.         for (int i = 0; i < loopNumber; i++) {
  28.             LockSupport.park();
  29.             System.out.print(str);
  30.             LockSupport.unpark(next);
  31.         }
  32.     }
  34.     private int loopNumber;
  36.     public ParkUnpark(int loopNumber) {
  37.         this.loopNumber = loopNumber;
  38.     }
  39. }