JUC里的同步组件
1.countDownLatch（闭锁）
countDownLatch基于AQS的成员变量state实现的计数器，每次执行countDown()方法时，计数器减1，执行await()方法会阻塞线程直到计数器为0。我的理解 就类似一个大门一样，当计数器为0 大门才会打开，所有的线程才能通过大门，继续执行。一般用在多任务执行，最后汇总（即最终的操作依赖于所有子任务执行完成的结果），所有子任务完成之后，才能进行最终操作，代码示例如下
public static void main(String[] args) throws InterruptedException { CountDownLatch countDownLatch = new CountDownLatch(2); ExecutorService executorService = Executors.newFixedThreadPool(2); executorService.submit(()->{ try { Thread.sleep(10); System.out.println("child threadOne over"); } catch (InterruptedException e) { e.printStackTrace(); }finally { countDownLatch.countDown(); } }); executorService.submit(()-> { try { Thread.sleep(10); System.out.println("child threadTwo over"); } catch (InterruptedException e) { e.printStackTrace(); }finally { countDownLatch.countDown();//原子操作，同时只能有一个线程操作计数器 } }); Thread.sleep(1000); System.out.println("wait all child thread over"); try { countDownLatch.await(2, TimeUnit.SECONDS);//调用await()会一直阻塞，直到countDown计数器为0 （大门一直关闭，直到计数器为0打开），并发继续执行 System.out.println("all child thread over"); //调用await(2, TimeUnit.SECONDS) ,超过这个时间，（大门打开）线程不阻塞，并发继续执行 } catch (InterruptedException e) { e.printStackTrace(); } executorService.shutdown(); }
2.Cyclicbarrier（回环屏障）
类似于闭锁（也通过计数器实现），每个线程执行完任务之后，执行await()方法，计数器减1，阻塞自己，直到所有线程都执行await()方法，即到达栅栏的位置，栅栏打开，然后可以执行一个所有子线程全部到达屏障后的任务。栅栏之后会被重置，以便于下次使用。（而闭锁是一次性的）。代码示例如下；
/** * 假设一个任务分三步，每一步让两个线程并发执行，下一步执行的条件是上一步必须执行完。 */ public class CyclicBarrierDemo2 { private static CyclicBarrier cyclicBarrier = new CyclicBarrier(2); public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(2); executorService.execute(() -> { try { System.out.println(Thread.currentThread() + "step1"); cyclicBarrier.await(); System.out.println(Thread.currentThread() + "step2"); cyclicBarrier.await(); System.out.println(Thread.currentThread() + "step3"); }catch (Exception e) { } }); executorService.execute(() -> { try { System.out.println(Thread.currentThread() + "step1"); cyclicBarrier.await(); System.out.println(Thread.currentThread() + "step2"); cyclicBarrier.await(); System.out.println(Thread.currentThread() + "step3"); }catch (Exception e) { } }); executorService.shutdown(); } }
CyclicBarrier内部维护两个变量parties和count,当count计数值为0，会把parties重新赋值给count，达到重复使用的效果
“如果对await()的调用超时，线程中断，那么栅栏打破，所有阻塞的线程抛异常。如果通过栅栏，那么await()为每个线程返回一个唯一到达索引号，可以利用这些索引号选举出一个领导线程，让他执行特殊的操作”这句话出自《Java并发编程实战》，是基于源码讨论的
总结：countDownLatch简单，只能使用一次，CyclicBarrier可多次使用，还有一个重要的区别是 countDownLatch中子线程执行countDown后，只是告诉了主线程执行完毕，计数器减1，但是子线程还是继续执行的。CyclicBarrier就不同了，子线程执行await()方法后，不会再继续执行，直到所有子线程执行完 打开屏障，子线程才会继续执行
并且有获取阻塞线程数，判断线程是否中断的方法可以使用，还可以初始化时候指定一个所有线程通过栅栏后的任务，执行，代码如下
final CyclicBarrier c = new CyclicBarrier(3,()->{ System.out.println("all thread return"); });
3.Semaphore（信号量）
用来控制某个资源可以同时被访问的线程数量，
内部计数器是递增的.把它比作是控制流量的红绿灯，比如XX马路要限制流量，只允许同时有一百辆车在这条路上行使，其他的都必须在路口等待，所以前一百辆车会看到绿灯，可以开进这条马路，后面的车会看到红灯，不能驶入XX马路，但是如果前一百辆中有五辆车已经离开了XX马路，那么后面就允许有5辆车驶入马路，这个例子里说的车就是线程，驶入马路就表示线程在执行，离开马路就表示线程执行完成，看见红灯就表示线程被阻塞，不能执行。可以做流量控制，代码示例如下：
/** * * 同时只能有10个线程保存数据 */ public class SemaphoreDemo3 {
private final static int threadCount = 20;
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
//只能有3个线程访问
final Semaphore semaphore = new Semaphore(3);//并发数为3
for (int i = 0; i < threadCount; i++) {
final int threadNum = i ;
executorService.execute(() -> {
try {
semaphore.acquire(); //获取一个许可
test(threadNum); //需要做并发控制的代码，同时只有三个线程可以访问
semaphore.release(); //释放一个许可
}catch (Exception e) {
log.info("exception",e);
}
});
}
executorService.shutdown();
}
private static void test(int threadNum) throws Exception {
log.info("{}",threadNum);
Thread.sleep(1000);
}
}
