题目描述如下：
编写一个程序，开启三个线程，这三个线程的 ID 分别是 A、B 和 C，每个线程把自己的 ID 在屏幕上打印 10 遍，要求输出结果必须按 ABC 的顺序显示，如 ABCABCABC... 依次递推
这是一道经典的多线程编程面试题，首先吐槽一下，这道题的需求很是奇葩，先开启多线程，然后再串行打印 ABC，这不是吃饱了撑的吗？不过既然是道面试题，就不管这些了，其目的在于考察你的多线程编程基础。就这道题，你要是写不出个三四种解法，你都不好意思说你学过多线程。哈哈开玩笑，下面就为你介绍一下本题的几种解法。
1、最简单的方法——使用 LockSupport
LockSupport 是java.util.concurrent.locks包下的工具类，它的静态方法unpark()和park()可以分别实现阻塞当前线程和唤醒指定线程的效果，所以用它解决这样的问题简直是小菜一碟，代码如下：
public class PrintABC {
static Thread threadA, threadB, threadC;
public static void main(String[] args) {
threadA = new Thread(() -> {
for (int i = 0; i < 10; i++) {
// 打印当前线程名称
System.out.print(Thread.currentThread().getName());
// 唤醒下一个线程
LockSupport.unpark(threadB);
// 当前线程阻塞
LockSupport.park();
}
}, "A");
threadB = new Thread(() -> {
for (int i = 0; i < 10; i++) {
// 先阻塞等待被唤醒
LockSupport.park();
System.out.print(Thread.currentThread().getName());
// 唤醒下一个线程
LockSupport.unpark(threadC);
}
}, "B");
threadC = new Thread(() -> {
for (int i = 0; i < 10; i++) {
// 先阻塞等待被唤醒
LockSupport.park();
System.out.print(Thread.currentThread().getName());
// 唤醒下一个线程
LockSupport.unpark(threadA);
}
}, "C");
threadA.start();
threadB.start();
threadC.start();
}
}
执行结果如下：
ABCABCABCABCABCABCABCABCABCABC
Process finished with exit code 0
2、最传统的方法——使用synchronized 锁机制
这种方法就是直接使用 Java 的 synchronized 关键字，配合 Object 的 wait()和notifyAll()方法实现线程交替打印的效果，不过这种写法的复杂度和代码量都偏大。由于notify()和notifyAll()方法都不能唤醒指定的线程，所以需要三个布尔变量对线程执行顺序进行控制。另外要注意的就是，for 循环中的 i++需要在线程打印之后执行，否则每次被唤醒后，不管是不是轮到当前线程打印都会执行i++，这显然不是我们想要的。代码如下 (一般B、C线程和A线程的执行逻辑类似，只在A线程代码中进行详细注释说明)：
public class PrintABC {
// 使用布尔变量对打印顺序进行控制，true表示轮到当前线程打印
private static boolean startA = true;
private static boolean startB = false;
private static boolean startC = false;
public static void main(String[] args) {
// 作为锁对象
final Object o = new Object();
// A线程
new Thread(() -> {
synchronized (o) {
for (int i = 0; i < 10; ) {
if (startA) {
// 代表轮到当前线程打印
System.out.print(Thread.currentThread().getName());
// 下一个轮到B打印，所以把startB置为true，其它为false
startA = false;
startB = true;
startC = false;
// 唤醒其他线程
o.notifyAll();
// 在这里对i进行增加操作
i++;
} else {
// 说明没有轮到当前线程打印，继续wait
try {
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}, "A").start();
// B线程
new Thread(() -> {
synchronized (o) {
for (int i = 0; i < 10; ) {
if (startB) {
System.out.print(Thread.currentThread().getName());
startA = false;
startB = false;
startC = true;
o.notifyAll();
i++;
} else {
try {
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}, "B").start();
// C线程
new Thread(() -> {
synchronized (o) {
for (int i = 0; i < 10; ) {
if (startC) {
System.out.print(Thread.currentThread().getName());
startA = true;
startB = false;
startC = false;
o.notifyAll();
i++;
} else {
try {
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}, "C").start();
}
}
执行结果如下：
ABCABCABCABCABCABCABCABCABCABC
Process finished with exit code 0
3、使用 Lock 搭配 Condition 实现
使用 synchronized 锁机制的写法着实有些复杂，何不试试 ReentrantLock？这是java.util.concurrent.locks包下的锁实现类，它拥有更灵活的 API，能够对多线程执行流程实现更精细的控制，特别是在搭配 Condition 使用的情况下，可以随心所欲地控制多个线程的执行顺序，来看看这个组合在本题中的使用吧，代码如下：
public class PrintABC {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
// 使用ReentrantLock的newCondition()方法创建三个Condition
// 分别对应A、B、C三个线程
Condition conditionA = lock.newCondition();
Condition conditionB = lock.newCondition();
Condition conditionC = lock.newCondition();
// A线程
new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
System.out.print(Thread.currentThread().getName());
// 叫醒B线程
conditionB.signal();
// 本线程阻塞
conditionA.await();
}
// 这里有个坑，要记得在循环之后调用signal()，否则线程可能会一直处于
// wait状态，导致程序无法结束
conditionB.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 在finally代码块调用unlock方法
lock.unlock();
}
}, "A").start();
// B线程
new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
System.out.print(Thread.currentThread().getName());
conditionC.signal();
conditionB.await();
}
conditionC.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "B").start();
// C线程
new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
System.out.print(Thread.currentThread().getName());
conditionA.signal();
conditionC.await();
}
conditionA.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "C").start();
}
}
执行结果如下：
ABCABCABCABCABCABCABCABCABCABC
Process finished with exit code 0
4、使用 Semaphore 实现
semaphore中文意思是信号量，原本是操作系统中的概念，JUC下也有个 Semaphore 的类，可用于控制并发线程的数量。Semaphore 的构造方法有个 int 类型的 permits 参数，如下：
public Semaphore(int permits) {...}
其中 permits 指的是该 Semaphore 对象可分配的许可数，一个线程中的 Semaphore 对象调用acquire()方法可以让线程获取许可继续运行，同时该对象的许可数减一，如果当前没有可用许可，线程会阻塞。该 Semaphore 对象调用release()方法可以释放许可，同时其许可数加一。Talk is cheap, show me the code!
public class PrintABC {
public static void main(String[] args) {
// 初始化许可数为1，A线程可以先执行
Semaphore semaphoreA = new Semaphore(1);
// 初始化许可数为0，B线程阻塞
Semaphore semaphoreB = new Semaphore(0);
// 初始化许可数为0，C线程阻塞
Semaphore semaphoreC = new Semaphore(0);
new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
// A线程获得许可，同时semaphoreA的许可数减为0,进入下一次循环时
// A线程会阻塞，知道其他线程执行semaphoreA.release();
semaphoreA.acquire();
// 打印当前线程名称
System.out.print(Thread.currentThread().getName());
// semaphoreB许可数加1
semaphoreB.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "A").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
semaphoreB.acquire();
System.out.print(Thread.currentThread().getName());
semaphoreC.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "B").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
semaphoreC.acquire();
System.out.print(Thread.currentThread().getName());
semaphoreA.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "C").start();
}
}
执行结果如下：
ABCABCABCABCABCABCABCABCABCABC
Process finished with exit code 0
5、总结
本文一共介绍了四种三个线程交替打印的实现方法，其中第一种方法最简单易懂，但是更能考察多线程编程功底的应该是第二和第三种方法，在面试中也更加分。只要把这几种方法熟练掌握并彻底理解，以后碰到此类题型就不用慌了。
