juc三种辅助类

CountDownLatch

计数器，适用于一次性事件同步，比如主线程等待多个子线程完成任务

//10个运动员跑步，所有人准备好了，比赛开始

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 1; i <=10 ; i++) {
            new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+"号同学准备中");
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName()+"号同学准备好了");
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            },String.valueOf(i)).start();
        }
        System.out.println("裁判正在等待所有人准备好");
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"所有人开始跑");
    }
}

结果

3号同学准备中
1号同学准备中
2号同学准备中
4号同学准备中
5号同学准备中
6号同学准备中
7号同学准备中
8号同学准备中
9号同学准备中
裁判正在等待所有人准备好
10号同学准备中
1号同学准备好了
4号同学准备好了
8号同学准备好了
7号同学准备好了
5号同学准备好了
3号同学准备好了
10号同学准备好了
9号同学准备好了
6号同学准备好了
2号同学准备好了
main所有人开始跑

CyclicBarrier

循环栅栏，能够让多个线程在一个同步点等待， 直到所有线程都到达这个点再一起继续执行

/**
 * 有好多个小朋友，他们要做的
 * 1.跑到起跑线
 * 2.准备好跑步
 * 3.开始跑步 
 * 我们要在所有小孩子2.准备好跑步 之后
 * 输出“所有小孩都准备好了” 
 * 然后小孩们开始跑步
 */


public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //有5个小孩
        int people = 5;
        CyclicBarrier barrier = new CyclicBarrier(people, () -> {
            System.out.println("所有小孩都准备好了");
        });
        for (int i = 1; i <= people; i++) {
            new Thread(()->{

                try {
                    System.out.println(Thread.currentThread().getName()+"跑到起跑线");
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName()+"准备好跑步");
                    barrier.await();
                    System.out.println(Thread.currentThread().getName()+"开始跑步");

                } catch (InterruptedException | BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            },i+"号小孩").start();
        }
    }
}

结果

2号小孩跑到起跑线
1号小孩跑到起跑线
3号小孩跑到起跑线
4号小孩跑到起跑线
5号小孩跑到起跑线
2号小孩准备好跑步
4号小孩准备好跑步
5号小孩准备好跑步
3号小孩准备好跑步
1号小孩准备好跑步
所有小孩都准备好了
1号小孩开始跑步
3号小孩开始跑步
5号小孩开始跑步
2号小孩开始跑步
4号小孩开始跑步

Semaphore

Semaphore作为多线程的许可证，线程进入 获取到许可证， 许可证分完了了，别人用不了 已分发许可证线程执行完任务，可以释放许可证，释放出来许可证，别的线程又能用了

//6辆车，三个车位，车位的车走了，别的车才能用
public class SemaphoreDemo {
    public static void main(String[] args) {
        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(new Random().nextInt(6));
                    System.out.println(Thread.currentThread().getName() + "------离开了了停车场");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally {
                    semaphore.release();
                }
            },i+"号车").start();
        }
    }
}

结果

3号车进入了停车场
2号车进入了停车场
1号车进入了停车场
1号车------离开了了停车场
4号车进入了停车场
3号车------离开了了停车场
6号车进入了停车场
4号车------离开了了停车场
5号车进入了停车场
6号车------离开了了停车场
2号车------离开了了停车场
5号车------离开了了停车场