JUC -辅助类

一、CountDownLatch(倒计时)

       等待所有线程跑完后返回值

 * CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。

 * 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，

 * 当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。

代码：

package com.cb.demo.example;

import java.util.concurrent.CountDownLatch;

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()+"\t离开教室");
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"\t班长关门走人");
    }

    private static void closeDoor() {
        for (int i = 0; i <6 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\t离开教室");
            },String.valueOf(i)).start();
        }
        System.out.println(Thread.currentThread().getName()+"\t班长关门走人");
    }
}

二、CyclicBarrier

阻塞等着所有线程执行完，开始执行任务

代码：

package com.cb.demo.example;

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

/**
 * 阻塞等着所有线程执行完，开始执行任务
 */
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{ System.out.println("*****召唤圣龙"); });


        for (int i = 0; i <7 ; i++) {
            final int tem=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\t收集到第："+tem+"颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }


}

三、Semaphore（信号灯）

控制线程释放

 在信号量上我们定义两种操作：

 * acquire（获取） 当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），

 *       要么一直等下去，直到有线程释放信号量，或超时。

 * release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。

 * 

 * 信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

代码

package com.cb.demo.example;

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

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(3);//模拟资源类，有3个空车位

        for (int i = 0; i <6 ; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();//acquire 获得
                    System.out.println(Thread.currentThread().getName()+"\t抢占到了车位");
                    //暂停4秒
                    try{ TimeUnit.SECONDS.sleep(4);}catch(InterruptedException e){e.printStackTrace();}
                    System.out.println(Thread.currentThread().getName()+"\t离开了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release(); //释放
                }
            },String.valueOf(i)).start();
        }
    }
}