三个线程交替按顺序打印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