JUC的常用辅助工具

CountDownLatch（减少计数）

原理：

CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。
  其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，
  当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行

 代码：

package com.thekingqj;

import java.util.concurrent.CountDownLatch;

/**
 * CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。
 *   其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，
 *   当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。
 *   题目：6个学生+班长在教室上自习，只有班长有钥匙锁门，班长只有等六个学生都走完才能锁门
 */
public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i <6 ; i++) {
            final int temp=i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+"\t"+temp+"离开教室");
                countDownLatch.countDown();
                    }, String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("班长离开教室");
    }
}

CyclicBarrier循环栅栏

原理：

字面意思是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，
  让一组线程到达一个屏障（也可以叫同步点）时被阻塞，
  直到最后一个线程到达屏障时，屏障才会开门，所有
  被屏障拦截的线程才会继续干活。
  线程进入屏障通过CyclicBarrier的await()方法。

样例：

package com.thekingqj;

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

/**
 *  * CyclicBarrier
 *  * 的字面意思是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，
 *  * 让一组线程到达一个屏障（也可以叫同步点）时被阻塞，
 *  * 直到最后一个线程到达屏障时，屏障才会开门，所有
 *  * 被屏障拦截的线程才会继续干活。
 *  * 线程进入屏障通过CyclicBarrier的await()方法
 */
public class CyclicBarrierDemo {
    public static void main(String[] args) {

        CyclicBarrier barrier = 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()+"\t第"+temp+"个龙珠已经收集到");
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();

        }

    }
}

Semaphore信号灯

原理：

 在信号量上我们定义两种操作：
  acquire（获取） 当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），
        要么一直等下去，直到有线程释放信号量，或超时。
  release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
  信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

代码：

package com.thekingqj;


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

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(3);

        for (int i = 0; i <6 ; i++) {
            new Thread(() -> {
                boolean flag=false;
                try {
                    semaphore.acquire();//获取信号量
                    flag=true;
                    System.out.println(Thread.currentThread().getName()+"\t"+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"\t"+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    if(flag){
                        semaphore.release();//释放当前信号量
                    }
                }
            }, String.valueOf(i)).start();
        }

    }
}