实际开发中，有时候一些场景需求让多个线程按照固定的顺序依次执行。这个时候就会使用这种模式。

这种模式说白了，就是给线程设定不同的条件，不符合条件的话，就算线程拿到锁也会释放锁进入等待；符合条件才让线程拿到锁能够执行代码，完毕之后再唤醒所有等待中的线程。

可以用wait/notify进行解决。让每个线程需要满足一定条件（顺序）才能执行，否则放开锁进入等待。

比如，两个线程交替打印奇偶数。

public static void main(String[] args) throws InterruptedException {//两个线程交替打印奇偶数int[] num={0};new Thread(()->{synchronized (num){while (true){try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}//打印偶数if(num[0]%2==0){logger.debug("{}",num[0]);num[0]++;}else{try {num.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}num.notify();}}}).start();new Thread(()->{synchronized (num){while (true){try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}//打印奇数if(num[0]%2!=0){logger.debug("{}",num[0]);num[0]++;}else{try {num.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}num.notify();}}}).start();
}

如果有多个线程进行顺序打印，使用ReentrantLock的条件变量、await、sigal会能比synchronized获得更好的性能，因为synchronized每次都唤醒所有的线程。比如说有n个线程，让n个线程循环依次打印n个数字，这时候可以让ReentrantLock创建n个条件变量，每个线程对应一个条件变量。当线程t发现还没轮到自己打印（不满足条件），就让线程t进入t-1条件变量进行等待；当线程t打印数字成功，就可以让条件变量t唤醒t+1的线程。

比如，让n条线程循环打印0-n的数字：

public static void main(String[] args) throws InterruptedException {//让n条线程循环依次打印0-n的数字int n=7;int[] num={0};ReentrantLock lock=new ReentrantLock();Condition[] conditions=new Condition[n];for (int i = 0; i < n; i++) {conditions[i]=lock.newCondition();}for (int i = 0; i < n; i++) {int finalI=i;new Thread(()->{lock.lock();try{while (true){if(num[0]==finalI){Thread.sleep(100);//轮到自己打印了logger.debug("{}",num[0]);num[0]++;if(num[0]==n){num[0]=0;}//打印完成，唤醒在当前条件变量中等待的线程（第i+1条线程）conditions[finalI].signal();}else{//没有轮到自己打印，释放锁，进入i-1的条件变量进行等待if(finalI==0){conditions[n-1].await();}else {conditions[finalI-1].await();}}}} catch (InterruptedException e) {throw new RuntimeException(e);} finally {lock.unlock();}},"线程"+i).start();}
}

结果：

分析：假设要让1000条线程循环依次打印从0到1000的数字

• 使用ReentrantLock
  • 最坏的情况下，最开始线程0抢到了锁，打印出0。第0、3-999条线程在第2条线程之前竞争到锁但是没法打印进入等待，第2条线程最后打印出2并唤醒在条件变量2中等待的线程3，此时只有线程2和线程3竞争锁，但是线程2会因为无法打印进入线程1的条件变量中等待。依此类推，每次都只有两条线程竞争锁。
• 使用synchronized
  • 最坏的情况下，最开始线程0抢到了锁，打印出0。第0、3-999条线程在第2条线程之前竞争到锁但是没法打印进入等待，第2条线程最后打印出2并唤醒其他999条线程。线程3在最坏的情况下依然是最后一个竞争到锁，然后再次唤醒999条线程……。每次都有1000条线程参与竞争锁。

以上的分析可以很明显看出来，ReentrantLock的条件变量对于提升性能是有巨大的优势的。当线程数量越多，性能差距越明显。

另外也可以用park/unpark实现，因为这两个方法也能让线程阻塞、唤醒线程。park和unpark没有对象锁的概念，也没有什么等待队列，它以线程为单位阻塞和唤醒线程。所以，想要按顺序执行，一开始让所有线程都停下来，接下来手动触发一个线程运行，并让这个线程只运行一次就结束或阻塞，并触发下一个线程运行，以此类推就能按顺序进行线程的执行。

park/unpark是最简洁的。

public class Main {static Logger logger = LoggerFactory.getLogger("main");static Thread t1;static Thread t2;static Thread t3;public static void main(String[] args) throws InterruptedException {//让线程1、2、3依次顺序打印a、b、c五次int loop=5;t1 = new Thread(() -> {for (int i = 0; i < loop; i++) {LockSupport.park();logger.debug("a");LockSupport.unpark(t2);}});t2 = new Thread(() -> {for (int i = 0; i < loop; i++) {LockSupport.park();logger.debug("b");LockSupport.unpark(t3);}});t3 = new Thread(() -> {for (int i = 0; i < loop; i++) {LockSupport.park();logger.debug("c");LockSupport.unpark(t1);}});t1.start();t2.start();t3.start();LockSupport.unpark(t1);}}