JUC学习（二）--Java多线程辅助类

多线程辅助类减少计数CountDownLatch（-1操作）

CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法之后的语句。
• CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，这些线程会阻塞
• 其它线程调用 countDown 方法会将计数器减 1(调用 countDown 方法的线程不会阻塞)
• 当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行；

场景：六个同学陆续离开教室之后才可以关门

初始场景：

// 六个同学陆续离开教室之后才可以关门
public class CountDownLatchDemo {

    public static void main(String[] args) {

        //六个同学陆续离开教室之后才可以关门
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " 号同学离开了教室");
            },String.valueOf(i)).start();
        }

        System.out.println(Thread.currentThread().getName() + " 班长锁门走人了");

    }

}

目前的输出结果

增加CountDownLatch解决

package com.vleus.juc.juc;

import java.util.concurrent.CountDownLatch;

/**
 * @author vleus
 * @date 2021年07月18日 10:22
 */
// 六个同学陆续离开教室之后才可以关门
public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {

        //创建CountDownLatch对象，设置初始值
        CountDownLatch countDownLatch = new CountDownLatch(6);

        //六个同学陆续离开教室之后才可以关门
        for (int i = 0; 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（+1操作）

CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作

场景：集齐七颗龙珠召唤神龙！

package com.vleus.juc.juc;

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

/**
 * @author vleus
 * @date 2021年07月18日 10:34
 */

//集齐七颗龙珠召唤神龙
public class CyclicBarrierDemo {

    //创建固定值
    private static final int NUMBER = 7;

    public static void main(String[] args) {

        //创建CyclicBarrier,达到指定值之后执行对应的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(NUMBER,() -> {
            System.out.println("集齐七颗龙珠召唤神龙");
        });

        //集齐七颗龙珠的过程
        for (int i = 1; i <= 7; i++) {
            new Thread(() -> {

                try {
                    System.out.println(Thread.currentThread().getName() + " 星球被收集到了");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

    }
}

信号灯Semaphore

Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方法获得许可证，release 方法释放许可

场景：6辆汽车，停3个车位

package com.vleus.juc.juc;

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

/**
 * @author vleus
 * @date 2021年07月18日 11:10
 */
//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();
        }
    }
}

执行效果：