常用的辅助类---CountDownLatch、CyclicBarrier、Semaphore

1.CountDownLatch（减法计数器）
2.CyclicBarrier（加法计数器）
3.Semaphore（信号量）

1.CountDownLatch（减法计数器）

//计数器
    //相当于一个房子内有6个人，必须等到6个人都走完才可以锁门
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {

        CountDownLatch countDownLatch = new CountDownLatch(6);
        for(int i =0;i<6;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"chuqu");
                countDownLatch.countDown();//数量减一
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归零，然后向下执行
        System.out.println("close door");
    }
}

原理：

countDownLatch.countDown() //数量减一

countDownLatch.await() //等待计数器归零，然后向下执行

每次有线程调用countDown（）数量减一；假设计数器变为0，countDownLatch.await（）就会被唤醒，继续执行！

2.CyclicBarrier（加法计数器）

package com.qi.demo01.Demo;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author zjq
 * @date 2020/3/27 14:55
 */
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         *
         */
                                                        //共同屏障点
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("总共有7个");
        });
        for(int i =0;i<7;i++){
            int temp=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集了"+temp+"龙之");
                try {
                    cyclicBarrier.await();//等待 当数量达到 7 （共同屏障点）的时候才能结束，若数量不能达到7的时候，程序就会一直呆在这个状态；当数量不满足7的时候，会继续往下走；
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

3.Semaphore（信号量）

package com.qi.demo01.Demo;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * @author zjq
 * @date 2020/3/27 15:12
 */
public class SemaphoreDemo {
    public static void main(String[] args) {
        //有六辆车，只有三个停车位。限流！！！
                                            //线程数量
        Semaphore semaphore = new Semaphore(3);
        for(int i=0;i<6;i++){
            new Thread(()->{
                //acquire() 得到
                //release() 释放
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"进来");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"出去");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            }).start();
        }
    }
}

原理：

semaphore.acquire(); 获得，如果已经满了，等待，等待到被释放为止

semaphore.release(); 释放；会将当前当前信号量释放，然后唤醒等待的线程。

作用：多个共享资源互斥的使用，并发限流，控制最大的线程数！