1.CountDownLatch
countDownLatch的作用是让一组线程等待其他线程完成工作以后在执行，相当于加强版的join(不懂可以百度一下join的用法)，一般在初始化的时候会在构造方法传入计数器，
后续，在其他线程中每次调用countDown方法计数器减一，一般在需要等待的线程中调用countDownLatch的await方法阻塞线程，在当计数器为0时，等待线程继续运行。
光看上面的定义描述不是很直观，我们再来结合代码看一下实际运用：
1 public class UseCountDownLatch { 2 3 static CountDownLatch latch = new CountDownLatch(6); 4 //初始化线程(只有一步，有4个) 5 private static class InitThread implements Runnable{ 6 7 @Override 8 public void run() { 9 System.out.println("Thread_"+Thread.currentThread().getId() 10 +" ready init work......"); 11 latch.countDown();//初始化线程完成工作了，countDown方法只扣减一次； 12 for(int i =0;i<2;i++) { 13 System.out.println("Thread_"+Thread.currentThread().getId() 14 +" ........continue do its work"); 15 } 16 } 17 } 18 //业务线程 19 private static class BusiThread implements Runnable{ 20 21 @Override 22 public void run() { 23 try { 24 latch.await(); 25 } catch (InterruptedException e) { 26 e.printStackTrace(); 27 } 28 for(int i =0;i<3;i++) { 29 System.out.println("BusiThread_"+Thread.currentThread().getId() 30 +" do business-----"); 31 } 32 } 33 } 34 35 public static void main(String[] args) throws InterruptedException { 36 //单独的初始化线程,初始化分为2步，需要扣减两次 37 new Thread(new Runnable() { 38 @Override 39 public void run() { 40 SleepTools.ms(1); 41 System.out.println("Thread_"+Thread.currentThread().getId() 42 +" ready init work step 1st......"); 43 latch.countDown();//每完成一步初始化工作，扣减一次 44 System.out.println("begin step 2nd......."); 45 SleepTools.ms(1); 46 System.out.println("Thread_"+Thread.currentThread().getId() 47 +" ready init work step 2nd......"); 48 latch.countDown();//每完成一步初始化工作，扣减一次 49 } 50 }).start(); 51 new Thread(new BusiThread()).start(); 52 for(int i=0;i<=3;i++){ 53 Thread thread = new Thread(new InitThread()); 54 thread.start(); 55 } 56 57 latch.await(); 58 System.out.println("Main do ites work........"); 59 } 60 }
运行结果可以看到，两个初始化线程先跑，当两个初始化线程跑完了，latch的计数器减为0，阻塞放开，主线程和业务线程继续往下运行。但是，在设计这部分算法的时候需要注意，有可能会出现计数器没有减为0，则线程一直阻塞，导致程序卡死。
countDownLatch一般使用在多线程并发之后需要对结果进行处理，而我们无法控制所有线程的执行时间，所以在这里加上阻塞，等到只有线程全部执行完。
2.CyclicBarrier
cyclicBarrier从业务角度来说，和countDownLatch比较类似(具体对比后面会专门介绍)，其作用类似一个屏障(英文中也是屏障的意思)，阻隔线程直到全部到达屏障点，放开屏障。一般可以用在多线程统计的时候，
从代码角度来看，cyclicBarrier有两个构造方法，CyclicBarrier(int parties)和CyclicBarrier(int parties, Runnable barrierAction)；
两个方法的区别是第一个只是记录了线程计数器的个数，而第二个不仅记录了计数器，当屏障放开时，会执行第二个参数线程的方法(第二个参数一般传入的是一个实现了Runnable的线程方法)
再来结合代码深入了解一下：
1 public class UseCyclicBarrier { 2 3 private static CyclicBarrier barrier 4 = new CyclicBarrier(5,new CollectThread()); 5 6 private static ConcurrentHashMap<String,Long> resultMap 7 = new ConcurrentHashMap<>();//存放子线程工作结果的容器 8 9 public static void main(String[] args) { 10 new Thread(){ 11 @Override 12 public void run() { 13 long id = Thread.currentThread().getId();//线程本身的处理结果 14 resultMap.put(Thread.currentThread().getId()+"",id); 15 Random r = new Random();//随机决定工作线程的是否睡眠 16 try { 17 if(r.nextBoolean()) { 18 Thread.sleep(2000+id); 19 System.out.println("Thread_"+id+" ....do something "); 20 } 21 System.out.println(id+"....is await"); 22 barrier.await(); 23 Thread.sleep(1000+id); 24 System.out.println("Thread_"+id+" ....do its business "); 25 } catch (Exception e) { 26 e.printStackTrace(); 27 } 28 } 29 }.start(); 30 for(int i=0;i<=3;i++){ 31 Thread thread = new Thread(new SubThread()); 32 thread.start(); 33 } 34 } 35 36 //负责屏障开放以后的工作 37 private static class CollectThread implements Runnable{ 38 39 @Override 40 public void run() { 41 StringBuilder result = new StringBuilder(); 42 for(Map.Entry<String,Long> workResult:resultMap.entrySet()){ 43 result.append("["+workResult.getValue()+"]"); 44 } 45 System.out.println(" the result = "+ result); 46 System.out.println("do other business........"); 47 } 48 } 49 50 //工作线程 51 private static class SubThread implements Runnable{ 52 53 @Override 54 public void run() { 55 long id = Thread.currentThread().getId();//线程本身的处理结果 56 resultMap.put(Thread.currentThread().getId()+"",id); 57 Random r = new Random();//随机决定工作线程的是否睡眠 58 try { 59 if(r.nextBoolean()) { 60 Thread.sleep(2000+id); 61 System.out.println("Thread_"+id+" ....do something "); 62 } 63 System.out.println(id+"....is await"); 64 barrier.await(); 65 Thread.sleep(1000+id); 66 System.out.println("Thread_"+id+" ....do its business "); 67 } catch (Exception e) { 68 e.printStackTrace(); 69 } 70 } 71 } 72 }
输出结果： 11....is await
12....is await
Thread_10 ....do something
10....is await
Thread_13 ....do something
13....is await
Thread_14 ....do something
14....is await
the result = [11][12][13][14][10]
do other business........
Thread_10 ....do its business
Thread_11 ....do its business
Thread_12 ....do its business
Thread_13 ....do its business
Thread_14 ....do its business
3.countDownLatch和cyclicBarrier区别
（1）countDownlatch的计数器由调用countDown方法次数决定，每次调用计数器减一，可以在一个线程中调用多次，而cyclicBarrier计数器取决调用await方法的线程个数。
(2) countDownLatch只能用一次，而cyclicBarrier可以循环使用。并且cyclicBarrier可以调用reset方法重置计数器，可以在线程故障重新启用线程调用。
(3) 二者在内部方法也有很多区别，具体有兴趣的可以去看看源码。