首先我们来实现一个功能:当我们启动一个系统的时候需要初始化许多数据,这时候我们可能需要启动很多线程来进行数据的初始化,只有这些系统初始化结束之后才能够启动系统。其实在Java的类库中已经提供了Semaphore、CountDownLatch、CyclicBarrier这3个类来帮我们实现这样类似的功能了。
一、信号灯 Semaphore
Semaphore sp = new Semaphore(int permits) 接受一个整数型的参数,表示有几盏灯。线程可以通过semaphore.acquire()获取一盏信号灯,通过semaphore.release()释放。它与 Lock 的区别就是 Lock 只能是一个锁,而 Semaphore 更像是多个锁的一个集合,像一个阻塞队列一样,当队列中的锁用完了,而你又需要锁的时候,你就必须等待其他的线程释放锁。
下面我们声明了只有 1 个灯的信号灯,然后启动 3 个线程同时去获取信号灯,另外还启动了 1 个线程每 2 秒就释放一次信号灯。
/**
* Semaphore 实现信号灯
* @author chenyr
* @time 2014-12-24 下午08:13:32
* All Rights Reserved.
*/
public class Semaphore1 {
public static void main(String[] args) {
final Semaphore sp = new Semaphore(1); //只声明一盏信号灯
//业务线程1
new Thread(new Runnable(){
public void run(){
try{
System.out.println(Thread.currentThread().getName() + "准备获取信号灯-A");
sp.acquire(); //获取信号灯
System.out.println(Thread.currentThread().getName() + "已获取信号灯-A");
}catch(Exception e){
e.printStackTrace();
}
}
}).start();
//业务线程2
new Thread(new Runnable(){
public void run(){
try{
System.out.println(Thread.currentThread().getName() + "准备获取信号灯-B");
sp.acquire(); //获取信号灯
System.out.println(Thread.currentThread().getName() + "已获取信号灯-B");
}catch(Exception e){
e.printStackTrace();
}
}
}).start();
//业务线程3
new Thread(new Runnable(){
public void run(){
try{
System.out.println(Thread.currentThread().getName() + "准备获取信号灯-C");
sp.acquire(); //获取信号灯
System.out.println(Thread.currentThread().getName() + "已获取信号灯-C");
}catch(Exception e){
e.printStackTrace();
}
}
}).start();
//检查线程
new Timer().schedule(new TimerTask(){
public void run(){
System.out.println("每10s释放一次信号灯");
sp.release();
System.out.println("信号灯已释放");
}
}, 2000, 2000); //每2秒释放一次信号灯
}
}
执行结果如下:
Thread-0准备获取信号灯-A
Thread-0已获取信号灯-A
Thread-1准备获取信号灯-B
Thread-2准备获取信号灯-C
每2s释放一次信号灯
信号灯已释放
Thread-1已获取信号灯-B
每2s释放一次信号灯
信号灯已释放
Thread-2已获取信号灯-C
每2s释放一次信号灯
信号灯已释放
从结果可以看出一开始 Thread-0 获得了锁,Thread-1 和 Thread-2 都在等待获取,直到检查线程 2 秒后释放信号灯,Thread-1 才获得了信号灯。而 Thread-2 是在检查线程再次释放锁的时候获取到的。
二、倒计时门栓 CountDownLatch
接受一个整数型的参数,可以通过countDownLatch.countDown()减少一个计时,countDownLatch.await()进行线程等待,等到countDownLatch中的计数到0之后就会恢复执行。CountDownLatch 与 Semaphore 的作用完全不同,CountDownLatch 是类似于集合点的一个类,当调用者到达一个数目就会触发一些操作。而 Semaphore 是一个类似于锁队列的东西,锁用完了就是用完了,而不会触发操作。
下面我们模拟跑步比赛的例子,用 3 个线程分别模拟 3 个运动员。而这其中有 3 个节点,分别是:
1、要等 3 个运动员都准备好了,裁判才能发开跑命令
2、3 个运动员要等裁判发令才能跑
3、裁判员要等 3 个运动员都到终点了才能宣布成绩
这 3 个时间点我们分别用一个 CountDownLatch 对象来表示,具体实现如下。
/**
* CountDownLatch同步工具
* 实例:模拟运动员跑步的例子(等待裁判发令,3个运动员才跑。等到3个运动员都跑完了,裁判才宣布成绩)
* @author chenyr
* @time 2014-12-25 下午07:49:25
* All Rights Reserved.
*/
public class CountDownLatch1 {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
//要等到3个运动都准备好了,裁判才能命令
final CountDownLatch waitCd = new CountDownLatch(3);
//裁判发1次命令,运动员就开始跑
final CountDownLatch orderCd = new CountDownLatch(1);
//要等到3个运动员到达终点,裁判才公布成绩
final CountDownLatch scoreCd = new CountDownLatch(3);
//模拟3个运动员
for(int i = 1; i <= 3; i++){
final int count = i;
Runnable runnable = new Runnable(){
public void run(){
try{
System.out.println("运动员" + count + "站在起跑线准备比赛了!");
waitCd.countDown(); //准备好
orderCd.await();
Thread.sleep((long)(Math.random() * 10000)); //模拟运动员隔多久听到命令
System.out.println("运动员" + count + "听到开跑命令,开跑!");
Thread.sleep((long)(Math.random() * 10000)); //模拟运动员用多长时间跑到终点
System.out.println("运动员" + count + "跑到了终点!");
scoreCd.countDown(); //跑到终点
}catch(Exception e){
e.printStackTrace();
}
}
};
service.execute(runnable);
}
//模拟裁判
Runnable runnable = new Runnable(){
public void run(){
try{
System.out.println("裁判已到位,正在等待运动员做好准备!");
waitCd.await();
System.out.println("所有运动员已经就位,裁判准备发令!");
Thread.sleep((long)(Math.random() * 10000)); //模拟裁判的准备时间
System.out.println("裁判:比赛开始! 跑!跑!跑!");
orderCd.countDown(); //开跑
scoreCd.await();
System.out.println("所有运动员已经到达终点,裁判宣布成绩!");
}catch(Exception e){
e.printStackTrace();
}
}
};
service.execute(runnable);
service.shutdown();
}
}
运行结果如下:
运动员2站在起跑线准备比赛了!
运动员3站在起跑线准备比赛了!
裁判已到位,正在等待运动员做好准备!
运动员1站在起跑线准备比赛了!
所有运动员已经就位,裁判准备发令!
裁判:比赛开始! 跑!跑!跑!
运动员1听到开跑命令,开跑!
运动员2听到开跑命令,开跑!
运动员1跑到了终点!
运动员3听到开跑命令,开跑!
运动员2跑到了终点!
运动员3跑到了终点!
所有运动员已经到达终点,裁判宣布成绩!
三、栅栏 CyclicBarrier
CyclicBarrier cb = new CyclicBarrier(int parties) 接受一个整数型的参数。线程可以通过cb.await()等待,只要正在等待的线程数目达到设定的参数,所有等待的线程就会恢复执行。CyclicBarrier 与 CountDownLatch 相似,都是要达到一样的人数才可以执行某些操作,只不过 CountDownLatch 是减操作,而 CyclicBarrier 是加操作。与 CyclicBarrier 相似的事件是集合点,即我们 5 个人周末一起去爬山,我们大家都要在某个地方等 5 个人到齐了再出发。
下面设置了两个集合点,只有当全部人到齐了第一个集合点之后,才会继续前往下一个集合点。
/**
* CyclicBarrier同步工具
* 等待所有线程到达之后再继续执行
* @author chenyr
* @time 2014-12-25 下午07:30:00
* All Rights Reserved.
*/
public class CyclicBarrier1 {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final CyclicBarrier cb = new CyclicBarrier(3); //一共要等到几个线程才继续执行
for(int i = 1; i <= 3; i++){
Runnable runnable = new Runnable(){
public void run(){
try{
Thread.sleep((long)(Math.random() * 10000));
System.out.println(Thread.currentThread().getName() + "已经到达集合点A,正在等待。目前已有" + (cb.getNumberWaiting() + 1) + "个线程在等待" );
cb.await();
System.out.println("全部线程到达A集合点");
Thread.sleep((long)(Math.random() * 10000));
System.out.println(Thread.currentThread().getName() + "已经到达集合点B,正在等待。目前已有" + (cb.getNumberWaiting() + 1) + "个线程在等待" );
cb.await();
System.out.println("全部线程到达B集合点");
}catch(Exception e){
e.printStackTrace();
}
}
};
service.execute(runnable);
}
}
}
运行结果如下:
pool-1-thread-2已经到达集合点A,正在等待。目前已有1个线程在等待
pool-1-thread-1已经到达集合点A,正在等待。目前已有2个线程在等待
pool-1-thread-3已经到达集合点A,正在等待。目前已有3个线程在等待
全部线程到达A集合点
全部线程到达A集合点
全部线程到达A集合点
pool-1-thread-1已经到达集合点B,正在等待。目前已有1个线程在等待
pool-1-thread-3已经到达集合点B,正在等待。目前已有2个线程在等待
pool-1-thread-2已经到达集合点B,正在等待。目前已有3个线程在等待
全部线程到达B集合点
全部线程到达B集合点
全部线程到达B集合点
四、CountDownLatch 和 CyclicBarrier 的区别
一般情况下对于两个非常相似的类,我们一般都会想当然地去把他们进行类比。对于 CountDownLatch 和 CyclicBarrier 两个类,我们可以看到CountDownLatch 类都是一个类似于集结点的概念,很多个线程做完事情之后等待其他线程完成,全部线程完成之后再恢复运行。不同的是CountDownLatch 类需要你自己调用 countDown() 方法减少一个计数,然后调用 await() 方法即可。而 CyclicBarrier 则直接调用 await() 方法即可。
所以从上面来看,CountDownLatch 更倾向于多个线程合作的情况,等你所有东西都准备好了,我这边就自动执行了。而 CyclicBarrier 则是我们都在一个地方等你,大家到齐了,大家再一起执行。