前言
前面我们讲了Java的线程模型和Thread，Runnable的基础相关，这一节我们来开下它们在具体场景下的应用。
join
有这样一种场景，比如线程A执行到一半，需要一个数据，这个数据需要线程B去执行修改，那该怎么实现这种业务呢，Thread.join()就登场了。
public class Main {
int num;
Thread threadA, threadB;
public Main() {
threadA = new Thread() {
@Override
public void run() {
System.out.println("====> A开始执行");
if (num == 0) {
try {
System.out.println("====> A需要B把num修改成5，A等待B执行完毕");
threadB.join();
System.out.println("====> B执行完毕，A重新开始执行，num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
threadB = new Thread() {
@Override
public void run() {
System.out.println("====> B开始执行");
num = 5;
}
};
}
public static void main(String[] args) {
Main main = new Main();
main.threadA.start();
main.threadB.start();
}
}
//输出，不加join
====> A开始执行
====> A需要B把num修改成5，A等待B执行完毕
====> B开始执行
====> B执行完毕，A重新开始执行，num = 0
//输出，加join，B先执行完毕
====> A开始执行
====> B开始执行
====> A需要B把num修改成5，A等待B执行完毕
====> B执行完毕，A重新开始执行，num = 5
可见看见，通过调用threadB.join方法让B先执行完毕，所以A得到num结果为5，如果不加，为0。
另一个例子
Thread threadA = new Thread() {
@Override
public void run() {
printNumber("threadA:" + Thread.currentThread().getName());
}
};
Thread threadB = new Thread() {
@Override
public void run() {
printNumber("threadB:" + Thread.currentThread().getName());
}
};
threadA.start();
threadB.start();
private void printNumber(String threadName) {
for (int i = 1; i <= 3; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName + "print:" + i);
}
}
//输出，A，B交替显示
threadA:Thread-0print:1
threadB:Thread-1print:1
threadB:Thread-1print:2
threadA:Thread-0print:2
threadB:Thread-1print:3
threadA:Thread-0print:3
假如我们想A和B分开显示怎么办，即先执行完线程A，再执行线程B，join这时又登场了。我们就可以修改线程B的代码，在B的run里面调用A.join，让A执行完毕。
Thread threadB = new Thread() {
@Override
public void run() {
System.out.println("threadB 开始等待 threadA");
try {
threadA.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("threadA执行完毕，可以执行threadB了");
printNumber("threadB:" + Thread.currentThread().getName());
}
};
//输出，A先执行完毕，B再执行
threadB 开始等待 threadA
threadA:Thread-0print:1
threadA:Thread-0print:2
threadA:Thread-0print:3
threadA执行完毕，可以执行threadB了
threadB:Thread-1print:1
threadB:Thread-1print:2
threadB:Thread-1print:3
wait,notify/notifyAll
还是上面的例子，假如我们想让A输出1后，转到B输出完毕，然后再回来输出A剩下的，该怎么办了，这就要用到锁机制。前一节我们讲了synchronized的相关用法。修改Thread代码：
Object object = new Object();
threadA = new Thread() {
@Override
public void run() {
synchronized (object) {
System.out.println("threadA 1");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("threadA 2");
System.out.println("threadA 3");
}
}
};
threadB = new Thread() {
@Override
public void run() {
synchronized (object) {
System.out.println("threadB 1");
System.out.println("threadB 2");
System.out.println("threadB 3");
//一定要通知唤醒，否则线程A一直等待
object.notifyAll();
}
}
};
//输出
threadA 1
threadB 1
threadB 2
threadB 3
threadA 2
threadA 3
可以看见A先输出1，B输出1,2,3，A再输出2,3。当A输出1后，调用wait方法吧线程A放入object的等待队列，并释放object锁。这是线程B去获取到object锁，执行输出1,2,3。执行完毕后一定要调用notifyAll通知等待队列的线程，否则它们会一直等待。A被唤醒后重新获取object的锁，并执行wait后面的代码。
再假如如果想让两个线程交替执行呢？假如A输出1个数，B再输出一个数，这样交替执行，该怎么办呢？这里我们可以借助一个flag来执行
volatile boolean flag;
threadA = new Thread() {
@Override
public void run() {
for (int i = 0; i < 5; ) {
synchronized (object) {
if (flag) {
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
i++;
System.out.println("threadA:" + i);
flag = true;
object.notify();
}
}
}
}
};
threadB = new Thread() {
@Override
public void run() {
synchronized (object) {
for (int i = 0; i < 5; ) {
if (!flag) {
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
i++;
System.out.println("threadB:" + i);
flag = false;
object.notify();
}
}
}
}
};
//输出
threadA:1
threadB:1
threadA:2
threadB:2
threadA:3
threadB:3
threadA:4
threadB:4
threadA:5
threadB:5
这里借助于一个flag，当flag为true时，A等待，否则A输出一个数，并把flag置为true，这样A输出一个数后A就会进入等待状态；同理，当flag为false，B等待，否则B输出一个数，把flag置为false，B进入等待状态。一直这样交替执行下去。
CountdownLatch
另一种情况，假如有A，B，C，D 4个线程，D要等A，B，C三个执行完毕后，D才执行，其中A，B，C三个是乱序执行，无先后顺序。那么D该如何知道A，B，C三个线程执行完呢？这就要用到CountdownLatch。
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
Thread threadD = new Thread() {
@Override
public void run() {
System.out.println("D开始等待A，B，C执行完毕");
try {
countDownLatch.await();
System.out.println("A,B,C执行完毕，D开始执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadD.start();
for (char name = 'A'; name <= 'C'; name++) {
final String threadName = "thread" + name;
new Thread() {
@Override
public void run() {
System.out.println(threadName + "开始执行");
try {
Thread.sleep(new Random().nextInt(100));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName + "执行完毕");
countDownLatch.countDown();
}
}.start();
}
//输出
D开始等待A，B，C执行完毕
threadA开始执行
threadB开始执行
threadC开始执行
threadC执行完毕
threadA执行完毕
threadB执行完毕
A,B,C执行完毕，D开始执行
可以看到A，B，C各自执行完后，D才开始执行。用之前的wait，notify已经不能完成了。CountDownLatch应用场景：比如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。
CyclicBarrier
再以上面CountDownLatch的例子，修改一下，假如A，B，C，D 4个线程互相等对方完成一些初始化操作后，再一起执行。即线程间互相等待，用CountDownLatch是无法完成的，这里就要用到CyclicBarrier。
CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
CyclicBarrier cyclicBarrier = new CyclicBarrier(4);
for (char name = 'A'; name <= 'D'; name++) {
final String threadName = "thread" + name;
new Thread() {
@Override
public void run() {
System.out.println(threadName + "开始初始化");
try {
Thread.sleep(new Random().nextInt(100));
System.out.println(threadName + "初始化完毕完毕，等待其他线程");
cyclicBarrier.await();
System.out.println(threadName + "继续开始执行");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}.start();
}
//输出
threadA开始初始化
threadC开始初始化
threadB开始初始化
threadD开始初始化
threadD初始化完毕完毕，等待其他线程
threadB初始化完毕完毕，等待其他线程
threadA初始化完毕完毕，等待其他线程
threadC初始化完毕完毕，等待其他线程
threadD继续开始执行
threadC继续开始执行
threadB继续开始执行
threadA继续开始执行
