2019独角兽企业重金招聘Python工程师标准>>> 
1. CountDownLatch
1.1说明：
CountDownLatch可以理解为一个计数器在初始化时设置初始值，当一个线程需要等待某些操作先完成时，需要调用await()方法。这个方法让线程进入休眠状态直到等待的所有线程都执行完成。每调用一次countDown()方法内部计数器减1,当计数达到0时，则所有的等待着开始执行。 可以实现一个线程（也可以是多个线程）等待其他线程来唤醒，也可以实现一个线程通知多个线程的效果。
- 举例：类似裁判一声口令下，所有的运动员才能开始奔跑，或者所有的运动员奔跑完后才有比赛结果。
- 核心方法两个：countDown()和await()
（1）countDown():使CountDownLatch维护的内部计数器减1,每个被等待的线程完成的时候调用。
（2）await():线程在执行到CountDownLatch的时候会将此线程置于休眠。
2.2使用案例：
模拟裁判发出命令后，3个运动员以不同的速度奔跑。等3个运动员都跑完后，裁判得到比赛结果。
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* CountDownLatch demo ：模拟裁判发出命令后，3个运动员以不同的速度奔跑。等3个运动员都跑完后，裁判得到比赛结果
*
* @author Smile
*/
public class CountdownLatchTest {
public static void main(String[] args) throws InterruptedException {
ExecutorService service = Executors.newCachedThreadPool();
// 创建一个“命令”计数器
final CountDownLatch cdOrder = new CountDownLatch(1);
// 创建三个“回应”计数器
final CountDownLatch cdAnswer = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + "正在准备接收命令");
// 等待“命令”计数器为0
cdOrder.await();
System.out.println("线程" + Thread.currentThread().getName() + "已收命令");
Thread.sleep((long) (Math.random() * 10000));
System.out.println("线程" + Thread.currentThread().getName() + "处理结束！回应命令处理结果");
// “回应”计数器减1
cdAnswer.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
service.execute(runnable);
}
// 主线程发命令CountDownLatch cdOrder命令
Thread.sleep((long) (Math.random() * 10000));
System.out.println("线程" + Thread.currentThread().getName() + "即将发布命令");
// “命令”计数器减1，“命令”计数器为0，开始唤醒cdOrder.await()的线程
cdOrder.countDown();
System.out.println("线程" + Thread.currentThread().getName() + "已发布命令，等待处理结果……");
// 等待“回应”计数器为0时，再继续执行
cdAnswer.await();
System.out.println("线程" + Thread.currentThread().getName() + "已收到全部结果结果。");
service.shutdown();
}
}
运行结果：
2. CyclicBarrier
2.1说明：
CyclicBarrier是一个同步工具类，它允许一组线程互相等待，直到到达某个公共屏障点。
- 举例：整个公司的人利用周末时间到集体郊游一样，先各自从家里出发到公司集合，再同时出发到公园分开游玩，在餐馆集合后再同时开始聚餐。这里的“公司集合”、“餐馆集合”就是指的是公共屏障点。
- 常用方法：
（1）await()方法：在调用await()方法后，CyclicBarrier将阻塞这个线程并将它置入休眠状态等待其它线程的到来。
2.2 与CountDownLatch的区别：
（1）与CountDownLatch不同的是该barrier在释放等待线程后可以重用，所以称它为循环（Cyclic）的屏障（Barrier）。
（2）CountDownLatch主要是实现了1个或N个线程需要等待其他线程完成某项操作之后才能继续往下执行操作，描述的是1个线程或N个线程等待其他线程的关系。CyclicBarrier主要是实现了多个线程之间相互等待，直到所有的线程都满足了条件之后各自才能继续执行后续的操作，描述的多个线程内部相互等待的关系。
2.3使用案例：
模拟线程1、线程2、线程3以不同时间到达集合点1后，再一起以不同的速度到达集合点2，等所有线程都到达集合点2后，再一起出发到集合点3。
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* CyclicBarrier
* Demo：模拟线程1、线程2、线程3以不同时间到达集合点1后，再一起以不同的速度到达集合点2，等所有线程都到达集合点2后，再一起出发到集合点3
*
* @author Smile
*/
public class CyclicBarrierTest {
/**
* @param args
*/
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
// 设置屏障，此屏障需要等待3个线程
final CyclicBarrier cb = new CyclicBarrier(3);
for (int i = 0; i < 3; i++) {
Runnable runable = new Runnable() {
@Override
public void run() {
try {
Thread.sleep((long) (Math.random() * 10000));
System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点1， 当前已有"
+ (cb.getNumberWaiting() + 1) + "个并发"
+ ((2 == cb.getNumberWaiting()) ? "。线程已经全部到达集合点1,继续往下走！" : ""));
cb.await(); // 设置第一次屏障，需等3个线程全部执行到此时，才继续往下
Thread.sleep((long) (Math.random() * 10000));
System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点2， 当前已有"
+ (cb.getNumberWaiting() + 1) + "个并发"
+ ((2 == cb.getNumberWaiting()) ? "。线程已经全部到达集合点2,继续往下走！" : ""));
cb.await(); // 设置第二次屏障，需等3个线程全部执行到此时，才继续往下
Thread.sleep((long) (Math.random() * 10000));
System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点3， 当前已有"
+ (cb.getNumberWaiting() + 1) + "个并发"
+ ((2 == cb.getNumberWaiting()) ? "。线程已经全部到达集合点3,完毕！" : ""));
cb.await(); // 设置第三次屏障，需等3个线程全部执行到此时，才继续往下
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
};
service.execute(runable);
}
service.shutdown();
}
}
运行结果：
3. Exchanger
3.1说明
用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交互数据，第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才彼此交换数据。
- 核心方法：
public V exchange(V x)：等待另一个线程到达交换点（如果当前线程没有被中断），然后将已知的对象传给它，返回接收的对象。
3.2使用案例：
模拟两个线程交换数据：当线程A调用Exchange对象的exchange()方法后，他会陷入阻塞状态，直到线程B也调用了exchange()方法，然后以线程安全的方式交换数据，之后线程A和B继续运行。
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Exchanger Demo:两个线程之间的信息交换
* 用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交互数据，第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才彼此交换数据
*
* @author xiao
*
*/
public class ExchangerTest {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final Exchanger exchanger = new Exchanger();
service.execute(new Runnable() {
@Override
public void run() {
try {
String data1 = "XMSSS";
System.out.println("线程" + Thread.currentThread().getName() + "正在把数据 " + data1 + "交换出去");
Thread.sleep((long) (Math.random() * 10000));
String data2 = (String) exchanger.exchange(data1);
System.out.println("线程" + Thread.currentThread().getName() + "换回的数据为 " + data2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
service.execute(new Runnable() {
@Override
public void run() {
try {
String data1 = "GRSXX";
System.out.println("线程" + Thread.currentThread().getName() + "正在把数据 " + data1 + "交换出去");
Thread.sleep((long) (Math.random() * 10000));
String data2 = (String) exchanger.exchange(data1);
System.out.println("线程" + Thread.currentThread().getName() + "换回的数据为 " + data2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
运行效果：
