前言
这三个类都是在java1.5的时候由Doug Lea大神添加于java.util.concurrent，这三个辅助类都基于AQS同步器框架实现，下面我们简单介绍下它们的简单使用
CountDownLatch
CountDownLatch类似是一个计数器，他可以实现需要所有任务都执行完毕才可以执行接下来的任务，日常场景中我们可以使用他来做并行分布运算，借用多核cpu对数据分别进行计算，然后再汇总，也可以实现在加载某些东西前初始化一些信息。
主要方法
public CountDownLatch(int count)；//构造函数
public void countDown()；//计数器-1
public void await() throws InterruptedException；//挂起
public boolean await(long timeout, TimeUnit unit);//与await()类似，这里可以指定时间，达到时间如果计数器没归0也可以执行下面的东西
简单例子
private static void countDownLatchApply() throws Exception {
//初始化2个
CountDownLatch countDownLatch = new CountDownLatch(2);
new Thread(() -> {
try {
System.out.println("我是线程" + Thread.currentThread().getName() + "我执行在"
+LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")));
//模拟处理耗时
Thread.sleep(2000L);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
}
}).start();
new Thread(() -> {
try {
System.out.println("我是线程" + Thread.currentThread().getName() + "我执行在"+
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")));
//模拟处理耗时
Thread.sleep(2000L);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
}
}).start();
countDownLatch.await();
new Thread(() -> {
System.out.println("我是线程" + Thread.currentThread().getName() + "我需要前面两个执行完我才可以执行，我执行在"+
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")));
}).start();
}
执行结果
我是线程Thread-1我执行在2019/05/15 08:05:36
我是线程Thread-0我执行在2019/05/15 08:05:36
我是线程Thread-2我需要前面两个执行完我才可以执行，我执行在2019/05/15 08:05:38
我们会看到线程2是需要在线程0和1执行玩后再执行的，我特意让线程休眠了2秒，后面的时间也印证了线程2是在线程0和线程1后2秒执行的
CyclicBarrier
回环栅栏，他可以使线程全部到达一个同步点后，再一起执行下面的动作，他是可重用的，等线程到达同步点，这个线程是可以被做其他使用的，我们姑且叫这个状态为可重用态，当调用await()，线程就为可重用态
主要方法
public CyclicBarrier(int parties);//构造方法
public CyclicBarrier(int parties, Runnable barrierAction);//构造方法，可实现更复杂的动作
public int await() throws InterruptedException, BrokenBarrierException;//挂起
public int await(long timeout, TimeUnit unit);//带时间，到期可执行下面操作
简单例子
private static void cyclicBarrierApply() {
CyclicBarrier cyclicBarrier=new CyclicBarrier(4, new Runnable() {
@Override
public void run() {
System.out.println("我是线程"+Thread.currentThread().getName()+",老板，我按照你的要求在他们向你汇报前检查了他们4个的工作，他们一会会亲自向你汇报");
}
});
for (int i = 0; i <4 ; i++) {
new Thread(() ->{
try {
Thread.sleep(2000L);
System.out.println("我是线程"+Thread.currentThread().getName()+",我的工作做完了，等其他线程工作好"
+"，我们一起去向老板汇报");
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}finally {
System.out.println("老板，我来向你汇报工作了");
}
}).start();
}
}
执行结果
我是线程Thread-0,我的工作做完了，等其他线程工作好，我们一起去向老板汇报
我是线程Thread-1,我的工作做完了，等其他线程工作好，我们一起去向老板汇报
我是线程Thread-3,我的工作做完了，等其他线程工作好，我们一起去向老板汇报
我是线程Thread-2,我的工作做完了，等其他线程工作好，我们一起去向老板汇报
我是线程Thread-2,老板，我按照你的要求在他们向你汇报前检查了他们4个的工作，他们一会会亲自向你汇报
我是线程Thread-2老板，我来向你汇报工作了
我是线程Thread-3老板，我来向你汇报工作了
我是线程Thread-1老板，我来向你汇报工作了
我是线程Thread-0老板，我来向你汇报工作了
我们可以看到所有线程最开始都在完成自己的工作，并等待其他线程一起向“老板”汇报，线程完成工作了，变为了可重用态，这个时候线程2被重用，他被“老板”安排在四个线程汇报工作前先检查他们的工作，也就是第二个构造方法的运用，最后四个线程一起去向“老板”汇报工作。
CountDownLatch与CyclicBarrier的比较
他们的功能有一些类似，CountDownLatch是所有线程都到达一个点才能执行下面的动作，而CyclicBarrier是所有线程都到达一个点再一起执行下面的动作，CountDownLatch不可被重用，CyclicBarrier可以被重用
Semaphore
信号量，它可用于对资源进行有效的控制，获取到许可就可以使用，使用完许可主动释放掉，获取不到就需要等到有许可可以使用
主要方法
public Semaphore(int permits) //参数表示许可数目，同时可以允许多少线程进行访问
public Semaphore(int permits, boolean fair) //fair表示是否是公平的，等待时间越久的越先获得许可
public void acquire() throws InterruptedException ; //获取一个许可 会造成阻塞
public void acquire(int permits) throws InterruptedException ; //获取permits个许可 会造成阻塞
public void release() ; //释放一个许可 会造成阻塞
public void release(int permits) ; //释放permits个许可 会造成阻塞
//下面四个方法与上面的一样，但是下面会立即获得结果，不会阻塞，操作失败就返回false
public boolean tryAcquire();
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException
public boolean tryAcquire(int permits)
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
简单例子
private static void semaphoreApply() throws Exception {
//仓库管理员
Semaphore semaphore = new Semaphore(4);
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
//向仓库管理员要一把钥匙
semaphore.acquire();
System.out.println("我是线程" + Thread.currentThread().getName() + "我成功申请到了一把钥匙");
Thread.sleep(3000L);
System.out.println("我是线程" + Thread.currentThread().getName() + "我使用好了钥匙");
//给管理员说我用好了
semaphore.release();
System.out.println("我是线程" + Thread.currentThread().getName() + "我已经将钥匙还回去了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
运行结果
我是线程Thread-0我成功申请到了一把钥匙
我是线程Thread-2我成功申请到了一把钥匙
我是线程Thread-1我成功申请到了一把钥匙
我是线程Thread-3我成功申请到了一把钥匙
我是线程Thread-2我使用好了钥匙
我是线程Thread-1我使用好了钥匙
我是线程Thread-4我成功申请到了一把钥匙
我是线程Thread-6我成功申请到了一把钥匙
我是线程Thread-0我使用好了钥匙
我是线程Thread-2我已经将钥匙还回去了
我是线程Thread-1我已经将钥匙还回去了
我是线程Thread-5我成功申请到了一把钥匙
我是线程Thread-0我已经将钥匙还回去了
我是线程Thread-3我使用好了钥匙
我是线程Thread-3我已经将钥匙还回去了
我是线程Thread-7我成功申请到了一把钥匙
我是线程Thread-5我使用好了钥匙
我是线程Thread-5我已经将钥匙还回去了
我是线程Thread-6我使用好了钥匙
我是线程Thread-7我使用好了钥匙
我是线程Thread-9我成功申请到了一把钥匙
我是线程Thread-4我使用好了钥匙
我是线程Thread-7我已经将钥匙还回去了
我是线程Thread-6我已经将钥匙还回去了
我是线程Thread-8我成功申请到了一把钥匙
我是线程Thread-4我已经将钥匙还回去了
我是线程Thread-9我使用好了钥匙
我是线程Thread-9我已经将钥匙还回去了
我是线程Thread-8我使用好了钥匙
我是线程Thread-8我已经将钥匙还回去了
我们可以看到，最开始只有4个获取到了许可，我在这里将线程休眠3秒，模拟耗时，在这期间没有其他线程获取到许可，并且同时也只能有四个在运行，每下一个获取到许可都必须是有线程释放许可,
参考资料：《java编程思想》
