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();
}
}
});
}
}
运行效果: