如何区分Java并发中的闭锁(Latch)和栅栏(CyclicB

闭锁概念理解

闭锁（Latch）：一种同步方法，可以延迟线程的进度直到线程到达某个终点状态。通俗地讲就是，一个闭锁相当于一扇大门，在大门打开之前所有线程都被阻断，一旦大门打开所有线程都将通过，但是一旦大门打开，所有线程都通过了，那么这个闭锁的状态就失效了，门的状态也就不能变了，只能是打开状态。也就是说闭锁的状态是一次性的，它确保在闭锁打开之前所有特定的活动都需要在闭锁打开之后才能完成。

闭锁应用场景

• 确保某个计算在其需要的所有资源都被初始化之后才继续执行。二元闭锁（包括两个状态）可以用来表示“资源R已经被初始化”，而所有需要R的操作都必须先在这个闭锁上等待。
• 确保某个服务在其依赖的所有其他服务都已经启动之后才启动。
• 等待直到某个操作的所有参与者都就绪在继续执行。（例如：多人游戏中需要所有玩家准备才能开始）
• 适用于王者荣耀，10个人都确认之后游戏开始

使用闭锁模拟王者荣耀

游戏玩家

public class Gamer implements Runnable {

    private CountDownLatch downLatch;
    private String name;

    public Gamer(CountDownLatch downLatch, String name) {
        this.downLatch = downLatch;
        this.name = name;
    }


    @Override
    public void run() {
        this.doPrepare();
        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
        } catch (InterruptedException ie) {
        }
        System.out.println(TimeUtils.getTimes() + this.name + "点击-->准备好了！");
        // 完成之后-1
        this.downLatch.countDown();
    }

    private void doPrepare() {
        System.out.println(TimeUtils.getTimes() + this.name + "进入游戏界面!");
    }
}

系统程序

public class GameCenter implements Runnable {

    private CountDownLatch downLatch;

    public GameCenter(CountDownLatch downLatch) {
        this.downLatch = downLatch;
    }

    @Override
    public void run() {
        System.out.println(TimeUtils.getTimes() + "游戏中心正在等待所有玩家就位......");
        try {
            // 等待操作
            this.downLatch.await();
        } catch (InterruptedException e) {
        }
        System.out.println(TimeUtils.getTimes() + "所有玩家都已经准备完成，开始进入游戏！");
    }

}

测试游戏

public class TestLatch {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        CountDownLatch latch = new CountDownLatch(10);
        List<Gamer> gamers = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Gamer gamer = new Gamer(latch, i + 1 + "");
            gamers.add(gamer);
        }

        GameCenter boss = new GameCenter(latch);
        executor.execute(boss);
        gamers.stream().forEach(executor::execute);

        // 游戏结束
        executor.shutdown();
    }
}

系统时间打印Util类

public class TimeUtils {
    public static String getTimes() {
        SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss.SSS");
        String formatStr = formatter.format(new Date());
        return "[" + formatStr + "]";
    }
}

输出结果

[03-01-2021 22:40:12.461]游戏中心正在等待所有玩家就位......
[03-01-2021 22:40:12.490]1进入游戏界面!
[03-01-2021 22:40:12.490]2进入游戏界面!
[03-01-2021 22:40:12.490]3进入游戏界面!
[03-01-2021 22:40:12.490]4进入游戏界面!
[03-01-2021 22:40:12.491]5进入游戏界面!
[03-01-2021 22:40:12.491]6进入游戏界面!
[03-01-2021 22:40:12.491]7进入游戏界面!
[03-01-2021 22:40:12.491]8进入游戏界面!
[03-01-2021 22:40:12.491]9进入游戏界面!
[03-01-2021 22:40:12.491]1点击-->准备好了！
[03-01-2021 22:40:12.491]10进入游戏界面!
[03-01-2021 22:40:12.491]8点击-->准备好了！
[03-01-2021 22:40:14.493]7点击-->准备好了！
[03-01-2021 22:40:14.493]9点击-->准备好了！
[03-01-2021 22:40:16.493]4点击-->准备好了！
[03-01-2021 22:40:17.495]5点击-->准备好了！
[03-01-2021 22:40:18.494]6点击-->准备好了！
[03-01-2021 22:40:19.494]10点击-->准备好了！
[03-01-2021 22:40:19.494]2点击-->准备好了！
[03-01-2021 22:40:20.495]3点击-->准备好了！
[03-01-2021 22:40:20.495]所有玩家都已经准备完成，开始进入游戏！

栅栏基本概念

栅栏（CyclicBarrier）栅栏类似于闭锁，它能阻塞一组线程直到某个事件发生。 栅栏与闭锁的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程。

栅栏应用场景

• 应用一些协议，比如几个家庭成员决定在某个地方集合，所有人在6：00在某地集合，到了以后要等待其他人，之后才能讨论去哪里吃饭。 并行迭代，将一个问题分成很多子问题，当一系列的子问题都解决之后(所有子问题线程都已经await（）），此时将栅栏打开，所有子问题线程被释放，而栅栏位置可以留着下次使用。

• 可用于集成测试模拟高并发场景，例如比如所有任务都到达完成之后才可以全部插入数据库保存。

栅栏使用案例

自动升级--满级之后中路集合，集合完成开始推塔

public class AutoPlay implements Runnable {

    private CyclicBarrier cyclicBarrier;
    private String name;

    public AutoPlay(CyclicBarrier cyclicBarrier, String name) {
        this.name = name;
        this.cyclicBarrier = cyclicBarrier;
    }


    @Override
    public void run() {
        System.out.println(TimeUtils.getTimes() + name + "正在执行个人升级任务");
        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
            System.out.println(TimeUtils.getTimes() + name + "已经完成个人升级任务");
            cyclicBarrier.await();
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            Thread.sleep(1000);
            System.out.println(TimeUtils.getTimes() + name + "等待所有人集合，一起推塔!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试游戏执行

public class BarrierTest {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        CyclicBarrier barrier = new CyclicBarrier(5);
        List<AutoPlay> autoPlayers = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            AutoPlay autoPlayer = new AutoPlay(barrier, i + 1 + "");
            autoPlayers.add(autoPlayer);
        }

        autoPlayers.stream().forEach(executor::execute);

        // 游戏结束
        executor.shutdown();
    }
}

[03-01-2021 22:46:29.380]2正在执行个人升级任务
[03-01-2021 22:46:29.380]4正在执行个人升级任务
[03-01-2021 22:46:29.380]5正在执行个人升级任务
[03-01-2021 22:46:29.380]1正在执行个人升级任务
[03-01-2021 22:46:29.380]3正在执行个人升级任务
[03-01-2021 22:46:29.381]2已经完成个人升级任务
[03-01-2021 22:46:33.385]1已经完成个人升级任务
[03-01-2021 22:46:34.384]3已经完成个人升级任务
[03-01-2021 22:46:36.384]4已经完成个人升级任务
[03-01-2021 22:46:38.381]5已经完成个人升级任务
[03-01-2021 22:46:39.387]2等待所有人集合，一起推塔!
[03-01-2021 22:46:39.387]5等待所有人集合，一起推塔!
[03-01-2021 22:46:39.387]1等待所有人集合，一起推塔!
[03-01-2021 22:46:39.387]3等待所有人集合，一起推塔!
[03-01-2021 22:46:39.387]4等待所有人集合，一起推塔!

推塔完成之后，还是可以继续升级再次执行推塔的

源码参考

以上就是关于闭锁和栅栏模式的理解，源码参考