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

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

代码如下：

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();
        }
    }
}

执行结果：

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

注意：

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

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