juc常用工具类

CountDownLatch

概念：

countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。

是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。

//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await()   
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit)  
//将count值减1
public void countDown()  

需求：希望等所有子线程执行完毕后，再退出。

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + " : 离开教室");
            }).start();
        }
        System.out.println(Thread.currentThread().getName() + " : 离开教室");
    }

使用countDownLatch可以实现：

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + " : 离开教室");
                countDownLatch.countDown();
            }).start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName() + " : 离开教室");
    }

CyclicBarrier

允许一组线程全部等待彼此达到共同屏障点的同步工具类。 循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。 屏障被称为循环 ，因为它可以在等待的线程被释放之后重新使用。

//parties 是参与线程的个数,Runnable表示最后一个到达线程要做的任务
public CyclicBarrier(int parties)
public CyclicBarrier(int parties, Runnable barrierAction)
//线程调用 await() 表示自己已经到达栅栏
public int await()
public int await(long timeout, TimeUnit unit)

案例：七龙珠召唤神龙

    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(7, ()->System.out.println("召唤神龙"));
        for (int i = 1; i < 8; i++) {
            new Thread(()->{
                System.out.println("收集到第"+Thread.currentThread().getName() + "个龙珠");
                try {
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },i+"").start();
        }
    }

Semaphore

　Semaphore也是一个线程同步的辅助类，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数

常用方法：

//构造方法，boolean值是是否公平设置，默认是false，效率高
Semaphore(int permits) 
Semaphore(int permits, boolean fair) 
//从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。
void acquire()
//释放一个许可，将其返回给信号量。
void release()
//返回此信号量中当前可用的许可数。
int availablePermits()
//查询是否有线程正在等待获取。
boolean hasQueuedThreads()

案例：以占车位为例，6辆车抢占3个车位

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                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();
                }
            },i+"").start();
        }
    }