JUC三大工具类(CountDownLatch,CyclicBarrier,Semaphore)

1.CountDownLatch递减计数器

/*当计数器为0时,才被唤醒*/
public class CountDownLatchDemo {

    public static void main(String[] args) throws Exception {
        //定义一个数值为 6 的计数器
        CountDownLatch countDownLatch = new CountDownLatch(6);
        //创建 6 个同学(线程)
        for (int i = 1; i <= 6; i++) {
            new Thread(( ) -> {
                try {
                    if (Thread.currentThread( ).getName( ).equals("同学6")) {
                        Thread.sleep(2000);
                    }
                    System.out.println(Thread.currentThread( ).getName( ) + "离开了");
                    //计数器减一,不会阻塞
                    countDownLatch.countDown( );
                } catch (Exception e) {
                    e.printStackTrace( );
                }
            }, "同学" + i).start( );
        }
        countDownLatch.await( ); // 当计数器为0时,才被唤醒
        System.out.println("全部离开了,现在的计数器为" + countDownLatch.getCount( ));
    }
}

2.CyclicBarrier循环栏珊

/*
CyclicBarrier 字面意思是可循环（Cyclic）使用的屏障（Barrier）。
它要做的事情是让一组线程到达一个屏障（同步点）时被阻塞，直到最后一个线程到达屏障时候，屏障才会开门。
所有被屏障拦截的线程才会运行
 */
public class CyclicBarrierDemo {

    private static int SIZE = 5;

    private static CyclicBarrier cb;

    public static void main(String[] args) {
        cb = new CyclicBarrier(SIZE);
        for (int i = 0; i < SIZE; i++) {
            new MyTask().start();
        }

    }

    static class MyTask extends Thread {
        @Override
        public void run() {
            try {

                System.out.println("线程" + Thread.currentThread().getName() + "正在执行同一个任务");
                // 以睡眠来模拟几个线程执行一个任务的时间
                Thread.sleep(1000);
                System.out.println("线程" + Thread.currentThread().getName() + "执行任务完成，等待其他线程执行完毕");
                // 用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
                cb.await();

            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕");

        }

    }

}

3.Semaphore信号量

/*
    定义最大许可证, 每个信号量最多只同时有一个许可证。
    使用 acquire 方法获得许可证，release 方法释放许可证
 */
public class SemaphoreDemo {

    public static void main(String[] args) throws Exception {
        //定义 3 个停车位
        Semaphore semaphore = new Semaphore(3);
        //模拟 6 辆汽车停车
        for (int i = 1; i <= 6; i++) {
            Thread.sleep(100);
            //停车
            new Thread(( ) -> {
                try {
                    System.out.println(Thread.currentThread( ).getName( ) + "找车位 ing");
                    semaphore.acquire( );
                    System.out.println(Thread.currentThread( ).getName( ) + "汽车停车成功!");
                    Thread.sleep(10000L); //停车中
                } catch (Exception e) {
                    e.printStackTrace( );
                } finally {
                    System.out.println(Thread.currentThread( ).getName( ) + "溜了溜了");
                    semaphore.release( );
                }
            }, "汽车" + i).start( );
        }
    }
}