题目描述
建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。
基本思路
并发编程核心是三大块：分工、互斥和同步。(出自极客时间APP中，王宝令的《Java并发编程实战》)
-
互斥
- 这道题并不涉及共享变量，所以不需要考虑互斥，首先排除。
-
同步
- 一眼就能看出这道题考的就是同步，那怎么同步呢？很容易想到的方法，就是每个线程打印前，等待别的线程通知；打印后，再去通知别的线程。
- 等待与唤醒，无非就是Object的wait、notify、notifyAll，以及Java并发包中Condition的await、signal、signalAll。Object的wait和notify只能作用于同一个锁对象，不能满足我们的需求。所以就需要使用后者。
-
分工：就是考虑每个线程要做什么事情，需要哪些成员变量
- 等待与唤醒
- 需要一个Lock变量
- 需要两个Condition变量，一个condition用来等待上个线程通知，一个condition用来通知下个线程。
- 打印字母
- 需要一个本地变量，存储这个线程要打印的字母。
- 等待与唤醒
具体代码
1.可重入锁以及try-with-resource
想玩一玩try-with-resource，但是发现无论是Lock还是ReentrantLock都没有实现AutoCloseable接口。网上查了一下，发现可以自己封装一下。
package concurrent;
import java.util.concurrent.locks.ReentrantLock;
public class CloseableReentrantLock extends ReentrantLock implements AutoCloseable {
public CloseableReentrantLock open() {
this.lock();
return this;
}
@Override
public void close() {
try {
this.unlock();
} catch (Exception e) {
System.out.println(e.toString());
}
}
}
2. 工作线程代码
package concurrent;
import java.util.concurrent.locks.Condition;
public class ConditionSyncPrinter implements Runnable{
private static final int PRINT_COUNT = 10;
private final CloseableReentrantLock lock;
private final Condition thisCondition;
private final Condition nextCondition;
private final char printChar;
public ConditionSyncPrinter(CloseableReentrantLock lock, Condition thisCondition, Condition nextCondition, char printChar) {
this.lock = lock;
this.thisCondition = thisCondition;
this.nextCondition = nextCondition;
this.printChar = printChar;
}
@Override
public void run() {
try(CloseableReentrantLock closeableLock = lock.open()) {
for (int i = 0; i < PRINT_COUNT; i++) {
try {
thisCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print(printChar);
nextCondition.signalAll();
}
}
}
}
3. 主方法
先出一版跑跑看
package concurrent;
import java.util.concurrent.locks.Condition;
public class Main {
public static void main(String[] args) {
CloseableReentrantLock lock = new CloseableReentrantLock();
Condition conditionA = lock.newCondition();
Condition conditionB = lock.newCondition();
Condition conditionC = lock.newCondition();
Thread printerA = new Thread(new ConditionSyncPrinter(lock, conditionA, conditionB, 'A'));
Thread printerB = new Thread(new ConditionSyncPrinter(lock, conditionB, conditionC, 'B'));
Thread printerC = new Thread(new ConditionSyncPrinter(lock, conditionC, conditionA, 'C'));
Thread signaler = new Thread(new Signaler(lock, conditionA));
printerA.start();
printerB.start();
printerC.start();
//这里会有问题
try(CloseableReentrantLock closeableLock = lock.open()) {
conditionA.signalAll();
}
动手一跑就会发现，卡住了。
为什么会卡住，答案当然很简单，肯定是我们最后1行的signalAll没有通知成功，导致printerA永远等待在await方法上。
那为什么signalAll方法会没通知成功呢？不是说好的happen-before规则吗？答案当然也很简单，我们在主线程中signalAll的时候，printerA线程还没准备好。
解决方法有两个：
- 我们新写一个唤醒线程，专门执行
conditionA.signalAll();来唤醒printerA，而不在主进程中搞唤醒。这是最推荐的做法。 - 如果一定要在主线程中唤醒呢？那等待printerA准备好了就行了。怎么等呢？用
Thread.sleep(100);，注意这里时间要留足，如果只睡1毫秒，仍然是没什么卵用的。
这两个解法就留给读者自己写着玩吧~
