countdownlatch
正如每个java文档所描述的那样，countdownlatch 是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。
countdownlatch是什么?
countdownlatch是在java1.5被引入的，跟它一起被引入的并发工具类还有cyclicbarrier、semaphore、concurrenthashmap和blockingqueue，它们都存在于java.util.concurrent包下。countdownlatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。
countdownlatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
countdownlatch类只提供了一个构造器：
public countdownlatch(int count) { }; //参数count为计数值
然后下面这3个方法是countdownlatch类中最重要的方法：
public void await() throws interruptedexception { }; //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, timeunit unit) throws interruptedexception { }; //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countdown() { }; //将count值减1
构造器中的计数值（count）实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且countdownlatch没有提供任何机制去重新设置这个计数值。
与countdownlatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用countdownlatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。
其他n 个线程必须引用闭锁对象，因为他们需要通知countdownlatch对象，他们已经完成了各自的任务。这种通知机制是通过 countdownlatch.countdown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当n个线程都调 用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。
countdownlatch使用例子
比如对于马拉松比赛，进行排名计算，参赛者的排名，肯定是跑完比赛之后，进行计算得出的，翻译成java识别的预发，就是n个线程执行操作，主线程等到n个子线程执行完毕之后，再继续往下执行。
import java.util.concurrent.countdownlatch;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
/**
* @author: chenhao
* @description:
* @date: created in 11:05 2018/11/23
* @modified by:马拉松比赛
*/
public class countdownlatchtest {
public static void main(string[] args) {
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() + "等待信号枪");
cdorder.await();
system.out.println("运动员" + thread.currentthread().getname() + "开跑");
thread.sleep((long)(math.random()*10000));
system.out.println("运动员" + thread.currentthread().getname() + "到达终点！");
cdanswer.countdown();
} catch (exception e) {
e.printstacktrace();
}
}
};
service.execute(runnable);
}
try {
thread.sleep(5000);
system.out.println("裁判" + thread.currentthread().getname() + "即将鸣信号枪");
cdorder.countdown();
system.out.println("裁判" + thread.currentthread().getname() + "已经鸣枪，等待运动员跑完");
cdanswer.await();
system.out.println("三个运动员都跑到了终点，裁判"+ thread.currentthread().getname() +"统计名次" );
} catch (exception e) {
e.printstacktrace();
}
service.shutdown();
}
}
运行结果：
cyclicbarrier
字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。
cyclicbarrier是什么?
cyclicbarrier 的字面意思是可循环使用（cyclic）的屏障（barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。cyclicbarrier默认的构造方法是cyclicbarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉cyclicbarrier我已经到达了屏障，然后当前线程被阻塞。
cyclicbarrier使用例子
实例代码如下：
public class cyclicbarriertest {
static cyclicbarrier c = new cyclicbarrier(2);
public static void main(string[] args) {
new thread(new runnable() {
@override
public void run() {
try {
c.await();
} catch (exception e) {
}
system.out.println(1);
}
}).start();
try {
c.await();
} catch (exception e) {
}
system.out.println(2);
}
}
输出
2 1
或者输出
1 2
如果把new cyclicbarrier(2)修改成new cyclicbarrier(3)则主线程和子线程会永远等待，因为没有第三个线程执行await方法，即没有第三个线程到达屏障，所以之前到达屏障的两个线程都不会继续执行。
cyclicbarrier还提供一个更高级的构造函数cyclicbarrier(int parties, runnable barrieraction)，用于在线程到达屏障时，优先执行barrieraction，方便处理更复杂的业务场景。代码如下：
public class cyclicbarriertest2 {
static cyclicbarrier c = new cyclicbarrier(2, new a());
public static void main(string[] args) {
new thread(new runnable() {
@override
public void run() {
try {
c.await();
} catch (exception e) {
}
system.out.println(1);
}
}).start();
try {
c.await();
} catch (exception e) {
}
system.out.println(2);
}
static class a implements runnable {
@override
public void run() {
system.out.println(3);
}
}
}
输出
3 1 2
下面我们来看看barrier循环使用的例子，下面例子中getnumberwaiting方法可以获得cyclicbarrier阻塞的线程数量
周末公司组织大巴去旅游，总共有三个景点，每个景点约定好游玩时间，一个景点结束后需要集中一起出发到下一个景点。
1 import java.util.concurrent.cyclicbarrier;
2 import java.util.concurrent.executorservice;
3 import java.util.concurrent.executors;
4
5 public class cyclicbarriertest {
6
7 public static void main(string[] args) {
8 executorservice service = executors.newcachedthreadpool();
9 final cyclicbarrier cb = new cyclicbarrier(3);
10 for(int i=0;i<3;i++){
11 runnable runnable = new runnable(){
12 public void run(){
13 try {
14 thread.sleep((long)(math.random()*10000));
15 system.out.println("线程" + thread.currentthread().getname() + "即将到达集合地点1，当前已有" + (cb.getnumberwaiting()+1) + "个已经到达，" + (cb.getnumberwaiting()==2?"都到齐了，继续走啊":"正在等候"));
16 cb.await();
17
18 thread.sleep((long)(math.random()*10000));
19 system.out.println("线程" + thread.currentthread().getname() + "即将到达集合地点2，当前已有" + (cb.getnumberwaiting()+1) + "个已经到达，" + (cb.getnumberwaiting()==2?"都到齐了，继续走啊":"正在等候"));
20 cb.await();
21 thread.sleep((long)(math.random()*10000));
22 system.out.println("线程" + thread.currentthread().getname() + "即将到达集合地点3，当前已有" + (cb.getnumberwaiting() + 1) + "个已经到达，" + (cb.getnumberwaiting()==2?"都到齐了，继续走啊":"正在等候"));
23 cb.await();
24 } catch (exception e) {
25 e.printstacktrace();
26 }
27 }
28 };
29 service.execute(runnable);
30 }
31 service.shutdown();
32 }
33 }
运行结果：
结果分析：第9行设置需要拦截的线程数为3，三个人一起出发先到第一个景点游玩，第一个景点游玩结束后，第一个到达集合地点一的时候，cb.getnumberwaiting()为0，所以当前有1个已经到达，到16行代码cb.await()处第一个到达的人开始等待剩余两人到达；
第二人到达后等待第三人，第三人到达时，cb.getnumberwaiting()为2，表示前面等待的人数为2，此时三个人都到达了集合地点一，同时出发前往集合地点二，此时接着执行第18行代码；同理三个人都到达集合地点二后再前往集合地点三，也就是执行第21行代码。
cyclicbarrier的应用场景
cyclicbarrier可以用于多线程计算数据，最后合并计算结果的应用场景。比如我们用一个excel保存了用户所有银行流水，每个sheet保存一个帐户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日均银行流水，最后，再用barrieraction用这些线程的计算结果，计算出整个excel的日均银行流水。
cyclicbarrier和countdownlatch的区别
- countdownlatch的计数器只能使用一次。而cyclicbarrier的计数器可以使用reset() 方法重置。所以cyclicbarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次。
- cyclicbarrier还提供其他有用的方法，比如getnumberwaiting方法可以获得cyclicbarrier阻塞的线程数量。isbroken方法用来知道阻塞的线程是否被中断。
semaphore
semaphore翻译成字面意思为 信号量，semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
semaphore是什么?
emaphore（信号量）是用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。把它比作是控制流量的红绿灯，比如一条马路要限制流量，只允许同时有一百辆车在这条路上行使，其他的都必须在路口等待，所以前一百辆车会看到绿灯，可以开进这条马路，后面的车会看到红灯，不能驶入马路，但是如果前一百辆中有五辆车已经离开了马路，那么后面就允许有5辆车驶入马路，这个例子里说的车就是线程，驶入马路就表示线程在执行，离开马路就表示线程执行完成，看见红灯就表示线程被阻塞，不能执行。
semaphore类位于java.util.concurrent包下，它提供了2个构造器：
public semaphore(int permits) { //参数permits表示许可数目，即同时可以允许多少线程进行访问
sync = new nonfairsync(permits);
}
public semaphore(int permits, boolean fair) { //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
sync = (fair)? new fairsync(permits) : new nonfairsync(permits);
}
下面说一下semaphore类中比较重要的几个方法，首先是acquire()、release()方法：
public void acquire() throws interruptedexception { } //获取一个许可
public void acquire(int permits) throws interruptedexception { } //获取permits个许可
public void release() { } //释放一个许可
public void release(int permits) { } //释放permits个许可
public boolean tryacquire() { }; //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryacquire(long timeout, timeunit unit) throws interruptedexception { }; //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryacquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryacquire(int permits, long timeout, timeunit unit) throws interruptedexception { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
semaphore使用例子
假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过semaphore来实现：
public class test {
public static void main(string[] args) {
int n = 8; //工人数
semaphore semaphore = new semaphore(5); //机器数目
for(int i=0;i<n;i++)
new worker(i,semaphore).start();
}
static class worker extends thread{
private int num;
private semaphore semaphore;
public worker(int num,semaphore semaphore){
this.num = num;
this.semaphore = semaphore;
}
@override
public void run() {
try {
semaphore.acquire();
system.out.println("工人"+this.num+"占用一个机器在生产...");
thread.sleep(2000);
system.out.println("工人"+this.num+"释放出机器");
semaphore.release();
} catch (interruptedexception e) {
e.printstacktrace();
}
}
}
}
执行结果：
工人0占用一个机器在生产... 工人1占用一个机器在生产... 工人2占用一个机器在生产... 工人4占用一个机器在生产... 工人5占用一个机器在生产... 工人0释放出机器 工人2释放出机器 工人3占用一个机器在生产... 工人7占用一个机器在生产... 工人4释放出机器 工人5释放出机器 工人1释放出机器 工人6占用一个机器在生产... 工人3释放出机器 工人7释放出机器 工人6释放出机器