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);
}

 }