并发辅助类

1.减计数器-CountDownLatch

• 允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

public class CountDownLatchDemo {

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

        //定义：允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。
        //用途：1.一个CountDownLatch为一个计数的CountDownLatch用作一个简单的开/关锁存器，或者门：
        //      所有线程调用await在门口等待，直到被调用countDown()的线程打开。
        //     2.一个CountDownLatch初始化N可以用来做一个线程等待，直到N个线程完成某项操作，或某些动作已经完成N次

        CountDownLatch countDownLatch = new CountDownLatch(20);
        for (int i=1 ;i<=20;i++){
           // new Thread(()->{
                countDownLatch.countDown();
                System.out.println(Thread.currentThread().getName()+">="+countDownLatch.getCount());
            //},String.valueOf(i)).start();

        }
        //特性：它不要求调用countDown线程等待计数到达零之前继续，
        // 它只是阻止任何线程通过await ，直到所有线程可以通过。
        System.out.println("我可以在Await方法之前执行");

        countDownLatch.await();

        System.out.println("我为什么在最后执行呢");
    }
}

2.加计数器-CyclicBarrier

• 等待多个操作完成，再执行下一步

public class CyclicBarrierDemo {

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

        //适用需等待多个操作完成，再执行下一步
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("舍利子集齐成功，如来重生");
        });

        for (int i=1;i<=7;i++){
            int finalI = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"：收集了"+ finalI +"颗");
                try {
                    //等待，舍利子集齐，一起向下执行
                    cyclicBarrier.await();

                    System.out.println("无天必须在如来重生之后，再死");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }



    }
}

3.Semaphore

• 限流
• 多个资源的互斥使用

public class SemaphoreDemo {

    public static void main(String[] args) {
        //限流：停车位为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(2);
                    System.out.println(Thread.currentThread().getName()+"离开了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //释放一个位置
                    semaphore.release();
                }

            },String.valueOf(i)).start();

        }
    }

}