JUC常用辅助类

常用辅助类（必会！！）

CountDownLatch

发音：康特挡辣起

package com.add;

import java.util.concurrent.CountDownLatch;

//计数器 +1

/**
 * 场景：放学后6个学生走完后，才关门！！！！ 保证了所有的人都走了，不会关在里面
 */
public class CountDownLatchDemo {


    public static void main(String[] args) throws InterruptedException {
        //倒计时总数是6
        //应用场景，必须要执行任务的时候，再使用！
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                //打印出谁走了
                System.out.println(Thread.currentThread().getName()+"Go out");
                countDownLatch.countDown();//数量-1

            },String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归零，然后再向下执行
        System.out.println("Close DOOR");
    }
}

原理:

1. 数量减1
2. 等待计数器归零假设

每次有现成调用countDown() 数量 -1，假设计数器变为0, countDownLatch.await() 就会被唤醒，继续执行！

CyclicBarrier

发音：赛课理科拜日也

1.加法计数器
代码示例

package com.add;

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

/**
 * 集齐7颗龙珠召唤神龙
 * <p>
 * 加法计数器，集齐颗，才能召唤，也就是7个步骤一定都走完了，才能走到最后一步
 */
public class CyclicBarrierDemo {


    //召唤龙珠的线程
    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
        System.out.println("召唤神龙成功");
    });

    //
    public static void main(String[] args) {
        for (int i = 1; i <= 7; i++) {
            //如果要在函数表达式里面使用则要用final 修饰
            final int temp = i;
            //lambda 能操作到 i 吗? 不能，要通过一个final 修饰的变量来赋值
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "收集" + temp + "个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

Semaphore 发音：samefour
意思：信号量，相当于一个通行证

举个例子
抢车位：
6车子–3个停车位置
123
456
代码案例：

package com.add;

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

public class SemaphoreDemo {

    public static void main(String[] args) {
        //参数默认线程数,停车位！ 限流的时候我们可能会用到，也就是线程只会进来3个，不能多了。
        Semaphore semaphore = new Semaphore(3);
        //我们要有6个车进来
        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                //acquire() 得到
                //首先我第一个车进来要得到一个停车位
                try {
                    semaphore.acquire();
                    //我要打印下当前哪个线程拿到了这个车位
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    //这个车停下来了，肯定要停一段时间，假设是2s
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName()+"离开车位");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //release() 释放
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }

    }

}

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