JUC-常用工具类使用

Semaphore 信号量

构造方法参数，指定信号量资源的总数

acquire方法，获得1个信号量资源，如果信号量满了，需要等待资源释放

release方法，释放1个信号量资源，然后通知其他等待的线程

常用于多个线程对同一个共享资源的互斥处理，可以做流量限流

代码示例：

6辆车，3个车位，抢车位

public class SemaphoreTest {

    public static void main(String[] args) {
        /**
         * 6辆车，3个停车位
          */
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <= 6 ; i++) {
            new Thread(()->{
                try {
                    // 获得停车位
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "号车获得停车位");
                    // 线程睡一秒
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName() + "号车离开停车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放资源
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}

CountDownLatch减法计数器

构造方法，指定计数器初始容量

countDown()方法，计数器容量减1

await()方法，等待技术器值归零，计数器归零之后，才能执行该代码后面的代码

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        // 减法计数器，参数是int类型
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(()-> {
                // 计数器执行减一操作
                System.out.println(Thread.currentThread().getName() + " go out");
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }

        // 等待计数器归零，才能执行下面的代码
        countDownLatch.await();

        System.out.println("close door");
    }
}

CyclicBarrier加法计数器

构造方法，参数1指定需要达到的线程数量，参数二，Runnable接口实现类，如果达到了要求数量会执行Runnable接口中的run方法

await()方法，等待线程数量达到指定数量，达到之后，执行参数二中的业务

代码实现：

集齐七颗龙珠，召唤神龙

public class CyclicBarrierTest {

    public static void main(String[] args) {
        // 两个参数，参数1，指定需要达到线程数量，参数2，线程数量达到后，执行Runnable中的run方法
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, ()->{
            System.out.println("集齐七颗龙珠，召唤神龙");
        });

        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            new Thread(()-> {
                System.out.println("集齐第一颗龙珠" + temp);
                try {
                    // 等到cyclicBarrier指定的线程数量达到7，就执行cyclicBarrier中指定写好的线程逻辑
                    cyclicBarrier.await();
                    System.out.println("没到7不会执行这里的代码");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}