concurrent包下的CyclicBarrier和CountDownLatch以及Semaphore_concurrent下的 countdownlatch与cyclicbarrier-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_20641565/article/details/78881925

本文深入探讨了Java并发编程中的三种核心工具：CyclicBarrier、CountDownLatch及Semaphore的使用方法与场景。通过具体示例展示了如何利用这些工具实现线程间的同步与限流。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

CyclicBarrier：

它可以让多个线程中执行得快的线程在某一个时间点阻塞，然后等待最后一个线程执行到该点的时候，同时往下执行。

示例代码：

public class CyclicBarrierDemo {

    static class Runner implements Runnable {
        private CyclicBarrier barrier;
        private String name;

        public Runner(CyclicBarrier barrier, String name) {
            this.barrier = barrier;
            this.name = name;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000 * (new Random()).nextInt(5));
                System.out.println(name + "开始阻塞等待");
                barrier.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(name + "阻塞完毕，全体执行");
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        CyclicBarrier barrier = new CyclicBarrier(3);
        ExecutorService executor = Executors.newFixedThreadPool(3);

        executor.submit(new Thread(new Runner(barrier, "t1")));
        executor.submit(new Thread(new Runner(barrier, "t2")));
        executor.submit(new Thread(new Runner(barrier, "t3")));

        executor.shutdown();
    }
}

CountDownLatch：

它和Thread的join方法很类似，但是join方法只能在上游线程都执行完成后面的线程才能执行，而CountDownLatch可以在上游线程执行的逻辑中自己控制，比如执行到某个逻辑的时候就可以让下面的线程执行，上游线程可以继续执行其他逻辑。

示例代码：

public class CountDownLatchDemo {

    public static void main(String[] args) {

        final CountDownLatch countDown = new CountDownLatch(2);

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t1开始执行，并调用await");
                    countDown.await();
                    System.out.println("t1执行完毕");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t2开始执行");
                    Thread.sleep(2000);
                    System.out.println("t2执行完毕");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDown.countDown();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t3开始执行");
                    Thread.sleep(5000);
                    System.out.println("t3执行完毕");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDown.countDown();
                }
            }
        }).start();

    }
}

Semaphore

它可以用于控制线程的并行个数。

示例代码：

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 只能5个线程同时访问
        final Semaphore semp = new Semaphore(5);
        // 模拟20个客户端访问  
        for (int index = 0; index < 20; index++) {
            final int num = index;
            new Thread() {
                public void run() {
                    try {
                        semp.acquire();
                        System.out.println("当前进来的线程: " + num);
                        Thread.sleep((long) (Math.random() * 10000));
                        semp.release();
                    } catch (InterruptedException e) {
                    }
                }
            }.start();
        }
    }
}