文章目录
线程通信是多线程应用开发中最常见的操作，除了wait notify方法，jdk提供了多种多样的api可以实现线程通信。
下面通过一个简单的题目看看jdk的多种方式实现线程通信。
题目
使用两个线程，一个线程打印1-26，另一个打印A-Z，交替打印。
方式1：wait notify
看到题目首先想到的就是wait notify，线程1每打印一次就等待，并唤醒线程2，线程2打印完，也等待并唤醒线程1
代码实现：
首先准备数据
public class PrintDemo {
private static final int LENGTH = 26;
private static int[] arrI = new int[LENGTH];
private static char[] arrC = new char[LENGTH];
//init data
static{
for (int i = 0; i < LENGTH; i++) {
arrI[i] = i+1;
arrC[i] = (char) ('A' + i);
}
}
//...
wait notify方式：启动两个线程轮流打印。代码注意的点就是，wait 和 notify方法必须在同步块内使用，for循环结束要notify阻塞线程，否则程序不会退出。
public void printWait(){
new Thread(() -> {
synchronized (this){
for (int i : arrI) {
System.out.print(i);
try {
this.notify();
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//notify blocked Thread after print otherwise the program won't exit
this.notify();
}
},"t1").start();
new Thread(() -> {
synchronized (this){
for (char i : arrC) {
try {
System.out.print(i);
this.notify();
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//notify blocked Thread after print otherwise the program won't exit
this.notify();
}
},"t2").start();
}
最终程序输出
1A2B3C4D5E6F7G8H9I10J11K12L13M14N15O16P17Q18R19S20T21U22V23W24X25Y26Z
如果要控制字母先打印，可以用CountDownLatch控制，当然也可以在t1线程把wait提到print前面，下面贴出用CountDownLatch的代码：
public void printWaitCDL(){
CountDownLatch latch = new CountDownLatch(1);
new Thread(() -> {
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (this){
for (int i : arrI) {
System.out.print(i);
try {
this.notify();
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//notify blocked Thread after print otherwise the program won't exit
this.notify();
}
},"t1").start();
new Thread(() -> {
synchronized (this){
for (char i : arrC) {
try {
System.out.print(i);
latch.countDown();
this.notify();
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//notify blocked Thread after print otherwise the program won't exit
this.notify();
}
},"t2").start();
}
注意不能把latch.await()放到synchronized里面，否则会死锁。
方式2：LockSupport
Thread t1 = null , t2 = null;
public void printLockSupport(){
t1 = new Thread(()->{
for (int i : arrI) {
System.out.print(i);
LockSupport.unpark(t2);
LockSupport.park();
}
},"t1");
t2 = new Thread(()->{
for (char i : arrC) {
LockSupport.park();
System.out.print(i);
LockSupport.unpark(t1);
}
},"t1");
t1.start();
t2.start();
}
原理是一样的，只不过LockSupport不用必须在synchronized里面使用，LockSupport允许精准唤醒某个线程。
方式3：Atomic
利用Atomic类的可见性，也可以完成功能，思路是设置一个共享变量控制当前轮到哪个线程执行。
static volatile boolean t1turn = true;
static AtomicInteger count = new AtomicInteger(0);
void printAtomic(){
new Thread(()->{
while (count.get()<LENGTH){
while (t1turn){
System.out.print(arrI[count.get()]);
t1turn = false;
}
}
},"t1").start();
new Thread(()->{
while (count.get()<LENGTH){
while (!t1turn){
System.out.print(arrC[count.getAndIncrement()]);
t1turn = true;
}
}
},"t2").start();
}
这里设置了两个共享变量，一个用于控制线程执行权，一个用作循环的计数。这里volatile和Atomic可以起到同样的效果，关键就是保证变量的可见性。
方式4：忙循环
上面的实现方式可用一个忙循环改造一下。
enum Turn {T1,T2}
volatile Turn turn = Turn.T1;
void printVolatile(){
new Thread(()->{
for (int i : arrI) {
while (turn != Turn.T1){}
System.out.print(i);
turn = Turn.T2;
}
},"t1").start();
new Thread(()->{
for (char i : arrC) {
while (turn != Turn.T2){}
System.out.print(i);
turn = Turn.T1;
}
},"t2").start();
}
以上两种方式区别就是不进行线程挂起，通过循环判断volatile共享变量的状态来实现交替打印，实际上并没有线程通信。
方式5：ReentrantLock Condition
wait notify + synchronized 这一套也可以用 ReentrantLock的Condition来代替：
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
void printLockCondition(){
new Thread(()->{
try {
lock.lock();
for (int i : arrI) {
System.out.print(i);
condition.signal();
condition.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//let other Thread run, and unlock
condition.signal();
lock.unlock();
}
},"t1").start();
new Thread(()->{
try {
lock.lock();
for (char i : arrC) {
System.out.print(i);
condition.signal();
condition.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
condition.signal();
lock.unlock();
}
},"t2").start();
}
方式6：ReentrantLock 2 Condition
可以用两个Condition，优化一下Condition的实现方式，实现精准唤醒某个线程。
ReentrantLock lock2 = new ReentrantLock();
Condition conditionT1 = lock2.newCondition();
Condition conditionT2 = lock2.newCondition();
void printLock2Condition(){
new Thread(()->{
try {
lock.lock();
for (int i : arrI) {
System.out.print(i);
conditionT2.signal();
conditionT1.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//let other Thread run, and unlock
conditionT2.signal();
lock.unlock();
}
},"t1").start();
new Thread(()->{
try {
lock.lock();
for (char i : arrC) {
System.out.print(i);
conditionT1.signal();
conditionT2.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
conditionT1.signal();
lock.unlock();
}
},"t2").start();
}
方式7：BlockingQueue
要实现线程阻塞自然可以想到阻塞队列，利用BlockingQueue的take阻塞方法，也可以实现两个线程交替输出。
static BlockingQueue<Integer> q1 = new ArrayBlockingQueue<>(1);
static BlockingQueue<Character> q2 = new ArrayBlockingQueue<>(1);
void printBlockingQueue(){
new Thread(()->{
for (int i : arrI) {
try {
q1.put(i);
System.out.print(q2.take());//blocked
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"t1").start();
new Thread(()->{
for (char i : arrC) {
try {
System.out.print(q1.take());
q2.put(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"t2").start();
}
方式8：TransferQueue
BlockingQueue的take方法是获取的时候阻塞，还可以用TransferQueue的transfer方法，放入就阻塞，直到元素被取走。
static TransferQueue<String> tq = new LinkedTransferQueue<>();
void printTransferQueue(){
new Thread(()->{
for (int i : arrI) {
try {
tq.transfer(String.valueOf(i));
System.out.print(tq.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"t1").start();
new Thread(()->{
for (char i : arrC) {
try {
System.out.print(tq.take());
tq.transfer(String.valueOf(i));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"t2").start();
}
总结
两个线程交替执行，可以利用wait notify方法，volatile变量线程可见性，Lock API，LockSupport的park unpark方法，阻塞队列API以及其他方式来实现。