并发编程实战：CountDownLatch和CyclicBarrier的使用（实战应用）

电玩女神 2023-02-24 03:54 63阅读 0赞

# 模拟一群朋友相约聚餐，大家都到了就开始吃饭，大家都吃完饭了就去结账，并且约定谁最后到达饭店，谁就买单。 #

代码如下：

package com.jinke.deliver.pool;
    
    import java.text.SimpleDateFormat;
    import java.util.Arrays;
    import java.util.Date;
    import java.util.List;
    import java.util.Random;
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReference;
    
    /**
     * @author flowyj
     * @create 2020-07-08 10:08
     * @desc CyclicBarrier：等所有的线程都完成一件事后再一起执行下一件事
     * 举例：当所有运动员都准备好了，在起跑线就位了，然后一起比赛
     **/
    public class CountDownLatchAndCyclicBarrierDemo {
    
        private static List<String> list = Arrays.asList("张三", "李四", "王五", "赵六", "陈七");
    
        public static void main(String[] args) {
            System.out.println(list.toString()+"相约今天去饭店聚餐，谁最后到谁买单。");
            AtomicReference<String> payUser = new AtomicReference<>("");
            Thread[] threads = new Thread[list.size()];
            CyclicBarrier cyclicBarrier = new CyclicBarrier(list.size(),
                    () -> {
                        payUser.set(Thread.currentThread().getName());
                        System.out.println("大家都到了，准备去吃饭吧，根据约定：【" + Thread.currentThread().getName() + "】你最后到达，今天的消费由你买单");
                        try {
                            System.out.println("所有人用餐中......");
                            TimeUnit.SECONDS.sleep(30);
                            /**
                             * 使用CountDownLatch来处理所有线程都执行完以后，再唤醒主线程继续做事
                             */
                            CountDownLatch latch = new CountDownLatch(list.size());
                            for (int i = 0; i < list.size(); i++) {
                                String name = list.get(i);
                                threads[i] = new Thread(() -> {
                                    try {
                                        TimeUnit.SECONDS.sleep(new Random().nextInt(20));
                                        System.out.println(name + "吃完饭了，等待其他人");
                                        latch.countDown();
                                    } catch (InterruptedException e) {
                                        e.printStackTrace();
                                    }
                                }, name);
                                threads[i].start();
                            }
                            try {
                                latch.await();
                                System.out.println("所有人都用餐完毕，根据约定【" + payUser + "】去结账");
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    });
    
            /**
             * 使用CyclicBarrier来处理等所有线程都就位了再统一一起开始下一件事情
             */
            for (int i = 0; i < list.size(); i++) {
                String name = list.get(i);
                threads[i] = new Thread(() -> {
                    try {
                        TimeUnit.SECONDS.sleep(new Random().nextInt(10));
                        System.out.println(name + "已到达饭店，到达时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                        cyclicBarrier.await();
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }, name);
                threads[i].start();
            }
        }
    }

执行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMDA4NzM5_size_16_color_FFFFFF_t_70][]

说明：代码中使用了CyclicBarrier来控制当所有的人都到达了饭店再一起去吃饭。使用CountDownLatch来控制，所有的人都用餐完毕后，再去买单。

注意：

1、new CountDownLatch（size）初始化size的时候，每一次countDown都会完成一个线程，当countDown的次数等于指定的size的时候，就会执行await()后面的代码。也就是说在一个线程里面可以countDown很多次

2、new CyclicBarrier(list.size()，Runnable)初始化指定的size，也就是说当等待的线程个数等于size-1 的时候，就会执行Runnable了

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMDA4NzM5_size_16_color_FFFFFF_t_70]: /images/20230209/4eea97597f8d4b488b979c397f7faa35.png