实际开发中，有时候一些场景需求让多个线程按照固定的顺序依次执行。这个时候就会使用这种模式。
这种模式说白了，就是给线程设定不同的条件，不符合条件的话，就算线程拿到锁也会释放锁进入等待；符合条件才让线程拿到锁能够执行代码，完毕之后再唤醒所有等待中的线程。
可以用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);
}
}
