三个线程交替按顺序打印ABC之条件队列的理解

如题。本文给出交替打印的代码示例，并解释了条件变量在代码实现中所起的作用。

• 使用三个线程，一个只负责打印A，另一个只负责打印B，最后一个只负责打印C
• 按顺序交替。即打印A后，才能打印B，打印B后，才能打印C

由于按序交替，最好采用条件队列来实现。初始时，只有打印A的条件满足 打印B、C的条件都不满足。A打印后，使得打印B的条件满足，同时打印A的条件由原来的满足变成不满足；B打印后，使得打印C的条件满足，同时打印B的条件由原来的满足变成不满足；C打印后，使得打印A的条件满足，同时打印C的条件由原来的满足变成不满足。

采用锁+条件队列实现的优势：
锁+条件队列是基于"通知-唤醒"机制实现的，比sleep+轮询的方式要高效。这篇文章最后第6点简要说明了这2种机制。

完整代码如下：

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

/**
 * @author psj
 * @date 20-3-7
 */
public class PrintABC {
    private ReentrantLock lock = new ReentrantLock();
    //与锁关联的条件队列,当打印条件不满足时,挂起线程(通知唤醒机制,而不是sleep或者轮询)
    private Condition printA = lock.newCondition();
    private Condition printB = lock.newCondition();
    private Condition printC = lock.newCondition();

    //初始化 打印A的条件成立,打印B不成立,打印C不成立
    private volatile boolean isA = true;
    private volatile boolean isB = false;
    private volatile boolean isC = false;


    public static void main(String[] args) {
        PrintABC pabc = new PrintABC();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        pabc.printA();
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName() + " 退出打印");
                        break;
                    }
                }
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        pabc.printB();
                    } catch (InterruptedException e) {
                        //响应中断退出打印
                        System.out.println(Thread.currentThread().getName() + " 退出打印");
                        break;
                    }
                }
            }
        }, "t2");

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        pabc.printC();
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName() + " 退出打印");
                        break;
                    }
                }
            }
        }, "t3");

        t2.start();
        t3.start();
        t1.start();


//        sleepMills(10 * 1000);
//        t1.interrupt();
    }

    public void printA() throws InterruptedException{
        try {
            lock.lock();
            while (!isA) {
                printA.await();
            }
            System.out.println(Thread.currentThread().getName() + " print A");
            sleepMills(2000);
            //A 已打印,将打印A的条件由原来的满足变成不满足
            isA = false;
            //将打印B的条件变成满足
            isB = true;
            //通知线程打印B
            printB.signal();
        }finally {
            lock.unlock();
        }
    }

    public void printB()throws InterruptedException {
        try {
            lock.lock();
            while (!isB) {
                printB.await();
            }
            System.out.println(Thread.currentThread().getName() + " print B");
            //模拟方法执行耗时
            sleepMills(2000);
            //打印B的条件由满足变成不满足
            isB = false;
            //使得打印C的条件变成满足
            isC = true;
            printC.signal();
        }finally {
            lock.unlock();
        }
    }

    public void printC()throws InterruptedException {
        try {
            lock.lock();
            while (!isC) {
                printC.await();
            }
            System.out.println(Thread.currentThread().getName() + " print C");
            sleepMills(2000);
            //C已打印,将打印C的条件由原来的满足变成不满足
            isC = false;
            //将打印A的条件变成满足
            isA = true;
            printA.signal();
        }finally {
            lock.unlock();
        }
    }

    private static void sleepMills(long mills) {
        try {
            TimeUnit.MILLISECONDS.sleep(mills);
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

再来看一个交替打印AB的示例。这里给出了2种实现思路，一种是基于 volatile变量；另一种是采用条件队列。对比了这2种实现之后，讨论了条件队列背后的原理(通知唤醒机制、线程调度、线程阻塞状态……)

import java.util.concurrent.TimeUnit;

/**
 * @author psj
 * @date 20-3-7
 */
public class PrintAB {

    private volatile boolean isA = true;

    public static void main(String[] args) {
        PrintAB pab = new PrintAB();

        Thread t1 = new Thread(() -> {
            while (true) {
                pab.printA();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            while (true) {
                pab.printB();
            }
        }, "t2");

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

    public void printA() {
        if (isA) {
            System.out.println(Thread.currentThread().getName() + " print A");
            //模拟方法执行耗时
            sleepMills(1000);
            isA = false;
        }
    }

    public void printB() {
        if (!isA) {
            System.out.println(Thread.currentThread().getName() + " print B");
            sleepMills(2000);
            isA = true;
        }
    }

    private static void sleepMills(long mills) {
        try {
            TimeUnit.MILLISECONDS.sleep(mills);
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

使用一个volatile变量协调2个线程交替打印A、B的顺序。此种方式是很消耗CPU的，因为：2个线程是在while true循环中不停地测试打印条件是否成立。另一种优雅的方式则是采用通知唤醒机制：当条件不成立时，让线程放弃cpu，挂起线程，进入阻塞状态(WAITING)，当条件成立后，再唤醒线程，让它再次去争抢cpu，执行打印。这可以通过条件队列来实现，代码如下：

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

/**
 * @author psj
 * @date 20-3-7
 */
public class PrintABCondition {
    private Lock lock = new ReentrantLock();
    private Condition pac = lock.newCondition();
    private Condition pbc = lock.newCondition();

    //决定打印A or 打印B 条件是否满足
    private volatile boolean printA = true;

    public void printA() throws InterruptedException{
        try {
            lock.lock();
            while (!printA) {
                //打印A的条件未满足,挂起线程,放弃cpu,进入WAITING状态
                pac.await();
            }
            //打印A的条件满足了,打印A
            System.out.println(Thread.currentThread().getName() + " print A");
            //模拟方法执行耗时
            sleepMills(1500);
            //A 已经打印完毕, 使得打印B的条件满足, 接下来发送通知 唤醒打印B的线程
            printA = false;
            pbc.signal();
        }finally {
            lock.unlock();
        }
    }

    public void printB() throws InterruptedException{
        try {
            lock.lock();
            while (printA) {
                //打印B的条件未满足,挂起线程,放弃cpu,进入WAITING状态
                pbc.await();
            }
            System.out.println(Thread.currentThread().getName() + " print B");
            sleepMills(2000);
            //B 已打印完毕,使得打印A的条件满足,接下来发送通知 唤醒打印A的线程
            printA = true;
            pac.signal();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        PrintABCondition pab = new PrintABCondition();

        Thread t1 = new Thread(() -> {
            while (true) {
                try {
                    pab.printA();
                } catch (InterruptedException e) {
                    //响应中断
                    break;
                }
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            while (true) {
                try {
                    pab.printB();
                } catch (InterruptedException e) {
                    break;
                }
            }
        }, "t2");

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

    private static void sleepMills(long mills) {
        try {
            TimeUnit.MILLISECONDS.sleep(mills);
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

看juc并发包Condition.java的await方法里面有一段注释：

In all cases, before this method can return the current thread must re-acquire the lock associated with this condition。When the thread returns it is guaranteed to hold this lock.

这里从打印A的线程角度来解释一下：打印A的线程在从 await()方法返回时，必须重新争抢锁，争抢到锁之后，就会再执行while循环测试条件是否满足，如果此时条件满足(printA变为true)了，那就往下执行。如果条件不满足(printA为false)，那么就放弃cpu,进入WAITING状态，等待唤醒。
从线程调度的角度来说，当执行Thread#start()后，线程从NEW状态变成RUNNABLE状态，此时线程具有运行的资格--可以被线程调度器选中占用cpu执行，但并不是说该线程一定占有cpu在运行了。由于"最小时间片"原则，每个线程一般都会占用cpu运行一小段时间，然后由于"抢占式调度"，就被调度器切换出去了，线程不再占有cpu了(这种情形下的切换是多线程并发执行所固有的性质)，与 "多个线程争抢同一把锁，未获得锁的线程被阻塞挂起，从而不再占有cpu了" 是不同的，要注意区分。

这里说一下为什么要在while循环里面测试条件，当条件不满足时，调用await方法使得线程放弃cpu，进入WAITING状态。为什么用while，if语句不可以吗？
我觉得用while循环的原因是：其它线程可能“无意”间调用了singal()使得该线程被唤醒了（又或者是线程因为某种未知原因唤醒了），线程醒来之后需要重新测试条件是否满足，所以只能用while循环。
实际上，await()底层是调用LockSupport#park(java.lang.Object)来挂起线程的，那看看该方法的注释，想起一个问题：当一个线程被阻塞挂起时，有哪些方法可以让它恢复执行？在开始讨论之前，再次明确一下：所谓恢复执行，只是使得线程"醒过来"具有执行的资格，并不一定保证线程就拿到了cpu，正在运行了，记住：抢占式调度，是由线程调度器来决定将哪个cpu分配给线程运行的。
OK，我觉得主要有两种方式唤醒线程，恢复执行。一种是"中断"，即线程通过响应 InterruptedException 异常，退出阻塞状态；另一种是其它线程发送"通知"，比如调用signal/signalAll方法(底层是调用LockSupport#unpark)，使得线程退出阻塞状态。
但是，看LockSupport#park方法的注释，还提到了一种情况：

The call spuriously (that is, for no reason) returns.

这句话也验证了，为什么只能用while循环(不能用if语句)来测试条件是否满足(比如打印AB示例代码中的 printA 条件变量)的一个原因，因为线程可能不知道什么原因被唤醒了，只有while循环才能保证线程醒来之后会重新测试条件是否满足。

额外补充一下，这里为什么是线程阻塞后，是WAITING状态，而不是BLOCKED状态呢？哈哈。看 Thread.java 类的关于线程状态描述的源码注释（hint:等待条件满足）就知道了。

使用条件队列的好处：

• 通知唤醒机制，代码高效
• 能清楚看到线程在哪个条件上阻塞，并发逻辑清晰

参考资料：

• 《JAVA并发编程实战》第14章 条件队列
• 谈谈多线程
  原文：https://www.cnblogs.com/hapjin/p/12432928.html