CountDownLatch、CyclicBarrier、Semaphore

1、CountDownLatch：
CountDownLatch只能使用一次；

countDown()：计数器的值依次减1；

实现减法计数器：

public class CountDownLatchTest {
    public static void main(String[] args) {
        /*优先执行，执行完毕之后，才能执行 main*/
        /*1、实例化计数器 10，即被减数为10*/
        CountDownLatch countDownLatch=new CountDownLatch(10);
        new Thread(()->{
            for(int i=0;i<9;i++){   /
                System.out.println("++++++Thread");
                countDownLatch.countDown();//countDown()  是计数器依次减一
            }
        }).start();

        for(int i=0;i<1;i++){
          countDownLatch.countDown();
        }

      /*  2、调用await方法*/
        try {
            countDownLatch.await();//await() 当计数器减为0，计算器停止，唤醒其他线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        for(int i=0;i<5;i++){
            System.out.println("main-----");
        }
    }
}

当CountDownLatch 的值减为0时无法恢复，因此不能循环使用，只能用一次；

结果为：

如果将源代码中的

     for(int i=0;i<1;i++){
          countDownLatch.countDown();
        }

这一段去掉，则会发现其下面的代码无法执行，结果变为：

这是因为：将

 for(int i=0;i<1;i++){
          countDownLatch.countDown();
        }

这一段代码去掉之后，CountDownLatch的值经过操作之后，变味了是1，而非0，那他就无法调用await()来唤醒下面的代码；await()只有计数器的值变为0的时候，才能起作用；

2、CyclicBarrier：

CyclicBarrier计数器的值可以恢复，可以循环使用；

CyclicBarrier实现加法计数器：

public class CyclicBarrierTest {

    public static void main(String[] args) {

        /*定义一个计数器，当计数器的值累加到10，则输出“放行”*/
        CyclicBarrier cyclicBarrier=new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("放行");
            }
        });

        for(int i=0;i<5;i++){
            final  int temp=i;
            new Thread(()-> {
                System.out.println("---->" + temp);
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

结果为：

因为 CyclicBarrier计数器的值可以恢复，所以可以循环使用；
当其增加到指定值后，又会清零，继续执行加法操作；

如图：

public class CyclicBarrierTest {

    public static void main(String[] args) {

        /*定义一个计数器，当计数器的值累加到5后，则输出“放行”*/
        CyclicBarrier cyclicBarrier=new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("放行");
            }
        });
        for(int i=0;i<15;i++){//CyclicBarrie是每次从0加到5之后，又清零，再重新加
            final  int temp=i;
            new Thread(()-> {
                System.out.println("---->" + temp);
                try {
                    cyclicBarrier.await();//await()执行CyclicBarrier的业务，await()中的Runnable执行一次之后，计数器清零，等待下一次执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }

    }
}

结果为：

3、Semaphore

acquire()：尝试占用一个信号量，失败的线程会阻塞直到有新的信号量
release()：释放一个信号量
acquire(int n)：尝试占用n个信号量，失败的线程会阻塞直到有新的信号量
release(int n)：释放n个信号量

/*
* Semaphore：实际开发中主要用来做限流操作，即限制可以访问某些资源的线程数量
*
* 初始化
* 获取许可
* 释放许可
* */
public class SemaphoreTest {

    public static void main(String[] args) {
        /*初始化*/
        Semaphore  semaphore=new Semaphore(5);//最多只能进五个人，每次容器内最多只能装5个人
        for(int i=0;i<10;i++){//共10个人
            new Thread(()->{
                try {
                    /*获得许可*/
                    semaphore.acquire();//acquire()：等待获取许可，如果没有名额，则等待
                    System.out.println(Thread.currentThread().getName()+"进入门店");
                    TimeUnit.SECONDS.sleep(5);//在门店内等待5秒
                    System.out.println(Thread.currentThread().getName()+"离开门店");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    /*释放许可*/
                    semaphore.release();//release()：释放许可，并且唤醒等待的线程
                }
            }).start();
        }
    }
}

结果为：

从运行结果中也能看出，每次进入门店内的人数最多只能是5个，只有当有人出来后，其他人才能进入门店；