JUC并发编程之Semaphore、CountDownLatch、CyclicBarrier协同工具

Semaphore是一个计数信号量，常用于限制可以访问某些资源的线程数量，即一种用来控制并发量的共享锁。
CountDownLatch是一个倒计数器，起跑信号。
CyclicBarrier是一个循环栅栏，排队摩天轮。
代码示例：
下面分别是三种并发协同工具的使用测试

public class SemaphoreDemo {
     
    static Semaphore sp = new Semaphore(6);
//    static KaneSemaphore sp = new KaneSemaphore(6);

    public static void main(String[] args) {
     
        for (int i = 0; i < 12; i++) {
     
            new Thread(new Runnable() {
     
                @Override
                public void run() {
     
                    try {
     
                        sp.acquire();//获取信号量
                    } catch (Exception e) {
     
                        e.printStackTrace();
                    }
                    System.out.println("当前信号量限制...");
                    try {
     
                        Thread.sleep(2000L);
                    } catch (InterruptedException e) {
     
                        e.printStackTrace();
                    }
                    System.out.println("执行完了");
                    sp.release();
                }
            }).start();
        }
    }
}

执行结果：

当前信号量限制...
当前信号量限制...
当前信号量限制...
当前信号量限制...
当前信号量限制...
当前信号量限制...
执行完了
当前信号量限制...
执行完了
执行完了
执行完了
当前信号量限制...
当前信号量限制...
当前信号量限制...
执行完了
执行完了
当前信号量限制...
当前信号量限制...
执行完了
执行完了
执行完了
执行完了
执行完了
执行完了
6个6个执行

public class CountDownLatchDemo {
     
    public static void main(String[] args) throws InterruptedException {
     
        CountDownLatch latch = new CountDownLatch(6);
//        KaneCountDownLatch latch = new KaneCountDownLatch(6);

        //一种方式
        for (int i = 0; i < 6; i++) {
     
            new Thread(new Runnable() {
     
                @Override
                public void run() {
     
                    System.out.println("开始准备...");
                    latch.countDown();//计数减一
                }
            }).start();
            Thread.sleep(1000L);
        }
        latch.await();//每个线程执行一次则-1，当lache为0时开始向下执行，就是这些现场都准备就绪，然后一起去干同一件事

//        //另一种方式
//        for (int i = 0; i < 6; i++) {
     
//            new Thread(new Runnable() {
     
//                @Override
//                public void run() {
     
//                    latch.countDown();
//                    try {
     
//                        latch.await();
//                        System.out.println("线程：" + Thread.currentThread().getName() + "执行完毕");
//                    } catch (InterruptedException e) {
     
//                        e.printStackTrace();
//                    }
//                }
//            }).start();
//        }

        System.out.println("开始干活...");
    }
}

执行结果

开始准备...
开始准备...
开始准备...
开始准备...
开始准备...
开始准备...
开始干活...

public class CyclicBarrierDemo {
     

    public static void main(String[] args) throws InterruptedException {
     
        CyclicBarrier barrier = new CyclicBarrier(4);
//        KaneCyclicBarrier barrier = new KaneCyclicBarrier(4);

        for (int i = 0; i < 100; i++) {
     
            new Thread(new Runnable() {
     
                @Override
                public void run() {
     
//                    barrier.await();
                    try {
     
                        barrier.await();
                    } catch (InterruptedException e) {
     
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
     
                        e.printStackTrace();
                    }
                    System.out.println("任务开始执行");
                }
            }).start();
            Thread.sleep(500L);
        }
    }
}

执行结果

任务开始执行
任务开始执行
任务开始执行
任务开始执行
任务开始执行
任务开始执行
任务开始执行
任务开始执行
任务开始执行
任务开始执行
任务开始执行
任务开始执行
...
4个4个执行