JUC辅助类
理论
语法
CountDownLatch: 减少计数
CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法之后的语句。 • 其它线程调用 countDown 方法会将计数器减 1(调用 countDown 方法的线程不会阻塞) • 当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行
构造方法：
CountDownLatch(int count): 创建一个 CountDownLatch 实例，指定需要等待的线程数量，即需要调用countDown()方法的次数。
等待方法：
await() throws InterruptedException: 让当前线程等待，直到计数器减为零，或者等待过程中被中断。如果计数器已经为零，则此方法立即返回。
减少计数器方法：
countDown(): 使计数器减 1。当计数器减为零时，所有因调用await()方法而在等待的线程都会被释放，可以继续执行。
//场景: 6 个同学陆续离开教室后值班同学才可以关门。
//1：设置初始值
//2：消耗初始值
//3：主线程等待值为0
public class CountDownLatchDemo {
//6个同学陆续离开教室之后，班长锁门
public static void main(String[] args) throws InterruptedException {
//创建CountDownLatch对象，设置初始值
CountDownLatch countDownLatch = new CountDownLatch(6);
//6个同学陆续离开教室之后
for (int i = 1; i <=6; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+" 号同学离开了教室");
//计数 -1
countDownLatch.countDown();
},String.valueOf(i)).start();
}
//等待
countDownLatch.await();
System.out.println(Thread.currentThread().getName()+" 班长锁门走人了");
}
}
CyclicBarrier: 循环栅栏
允许一组线程互相等待，直到到达某个公共屏障点，然后同时继续执行
CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作
构造方法：
CyclicBarrier(int parties): 创建一个 CyclicBarrier 实例，指定需要等待的线程数量。CyclicBarrier(int parties, Runnable barrierAction): 创建一个 CyclicBarrier 实例，同时指定所有线程到达屏障点后执行的动作。
等待方法：
-
await() throws InterruptedException, BrokenBarrierException: 让当前线程等待，直到所有线程都到达屏障点。如果当前线程不是最后一个到达的线程，则会被阻塞，直到所有线程到达；如果当前线程是最后一个到达的线程，则会唤醒所有等待的线程，并继续执行。 -
int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException: 让当前线程等待一段指定的时间，直到所有线程到达屏障点，或者超时。如果超时，会抛出 TimeoutException 异常。
//集齐7颗龙珠就可以召唤神龙
public class CyclicBarrierDemo {
//创建固定值
private static final int NUMBER = 7;
public static void main(String[] args) {
//创建CyclicBarrier
CyclicBarrier cyclicBarrier =
new CyclicBarrier(NUMBER,()->{
System.out.println("*****集齐7颗龙珠就可以召唤神龙");
});
//集齐七颗龙珠过程
for (int i = 1; i <=7; i++) {
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+" 星龙被收集到了");
//等待
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
},String.valueOf(i)).start();
}
}
}
Semaphore: 信号灯
Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方法获得许可证，release 方法释放许可
用于控制同时访问特定资源的线程数量。Semaphore 维护了一组许可证（permits），线程在访问资源之前必须先获得许可证，每次许可证的获取都会将许可证数量减少，释放许可证则会增加数量。
构造方法：
Semaphore(int permits): 创建一个 Semaphore 实例，指定初始的许可证数量。
获取许可证方法：
acquire() throws InterruptedException: 获取一个许可证，如果没有许可证可用，则当前线程会被阻塞，直到有许可证可用或者被中断。acquire(int permits) throws InterruptedException: 获取指定数量的许可证，如果当前可用的许可证数量小于请求的数量，则当前线程会被阻塞，直到有足够的许可证可用或者被中断。tryAcquire(): 尝试获取一个许可证，如果有可用的许可证，则立即返回 true；否则返回 false。tryAcquire(int permits): 尝试获取指定数量的许可证，如果有足够的可用许可证，则立即返回 true；否则返回 false。
释放许可证方法：
release(): 释放一个许可证，将许可证数量加一。如果有等待的线程在等待许可证，则其中一个会被唤醒并获取许可证。release(int permits): 释放指定数量的许可证，将许可证数量加上指定数量。
其他方法：
int availablePermits(): 获取当前可用的许可证数量。boolean hasQueuedThreads(): 判断是否有线程在等待获取许可证。
//6辆汽车，停3个车位
public class SemaphoreDemo {
public static void main(String[] args) {
//创建Semaphore，设置许可数量
Semaphore semaphore = new Semaphore(3);
//模拟6辆汽车
for (int i = 1; i <=6; i++) {
new Thread(()->{
try {
//抢占
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+" 抢到了车位");
//设置随机停车时间
TimeUnit.SECONDS.sleep(new Random().nextInt(5));
System.out.println(Thread.currentThread().getName()+" ------离开了车位");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//释放
semaphore.release();
}
},String.valueOf(i)).start();
}
}
}