JUC包下的常用工具类CountDownLatch，cyclicBarrier，semaphore

CountDownLatch 减法计数器

package com.qcby.lock;

import java.util.concurrent.CountDownLatch;

/**
 * @author HuangHaiyang
 * @date 2020/07/07
 * @description: description
 * @version: 1.0.0
 */
public class CountDownLatchTest {
    public static void main(String[] args) {
        //设置总数为10
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 1; i <=10 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                countDownLatch.countDown();//减一
            },"线程"+i).start();
        }
        try {
            countDownLatch.await();//等待计数器归零
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计数器已归零");
    }
}

线程1
线程2
线程3
线程4
线程5
线程6
线程7
线程10
线程9
线程8
计数器已归零

cyclicBarrier可以理解为加法计数器

package com.qcby.lock;

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

/**
 * @author HuangHaiyang
 * @date 2020/07/07
 * @description: description
 * @version: 1.0.0
 */
public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功！");
        });
        for (int i = 1; i <=7 ; i++) {
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收 集"+temp+"个龙珠");
                try {
                    cyclicBarrier.await(); // 等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
    //Thread-0收 集1个龙珠
    //Thread-1收 集2个龙珠
    //Thread-2收 集3个龙珠
    //Thread-3收 集4个龙珠
    //Thread-4收 集5个龙珠
    //Thread-5收 集6个龙珠
    //Thread-6收 集7个龙珠
    //召唤神龙成功！
}

semaphore 信号量

package com.qcby.lock;

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

/**
 * @author HuangHaiyang
 * @date 2020/07/07
 * @description: description
 * @version: 1.0.0
 */
public class SemaphoreTest {
    public static void main(String[] args) {

        //允许最大的线程数量
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <=20 ; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();//得到
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);//休息2秒
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();//释放
                }
            },"线程"+i).start();
        }

    }
    //线程1抢到车位
    //线程2抢到车位
    //线程3抢到车位
    //线程1离开车位
    //线程4抢到车位
    //线程2离开车位
    //线程5抢到车位
    //线程3离开车位
    //线程6抢到车位
    //线程4离开车位
    //线程8抢到车位
    //线程5离开车位
    //线程6离开车位
    //线程9抢到车位
    //线程7抢到车位
    //线程8离开车位
    //线程10抢到车位
    //线程7离开车位
    //线程9离开车位
    //线程11抢到车位
    //线程12抢到车位
    //线程10离开车位
    //线程13抢到车位
    //线程12离开车位
    //线程11离开车位
    //线程14抢到车位
    //线程15抢到车位
    //线程13离开车位
    //线程16抢到车位
    //线程14离开车位
    //线程17抢到车位
    //线程15离开车位
    //线程18抢到车位
    //线程16离开车位
    //线程19抢到车位
    //线程17离开车位
    //线程20抢到车位
    //线程18离开车位
    //线程19离开车位
    //线程20离开车位
    //
    //Process finished with exit code 0
}

原理：
semaphore.acquire() 获得，假设如果已经满了，等待，等待被释放为止！
semaphore.release(); 释放，会将当前的信号量释放 + 1，然后唤醒等待的线程！
作用： 多个共享资源互斥的使用！并发限流，控制最大的线程数