CountDownLatch和CyclicBarrier详解

news/2024/5/20 9:11:34 标签: JUC, 并发编程

1. CountDownLatch

1.1 简介

CountDownLatch 是 Java 中并发包（java.util.concurrent）提供的一种同步工具，用于在多线程环境中协调多个线程之间的执行顺序。它的作用是允许一个或多个线程等待其他线程完成操作。

CountDownLatch 通过一个计数器来实现，计数器的初始值由用户设置，每当一个线程完成一项任务后，计数器的值就会减一。当计数器的值变为零时，等待在 CountDownLatch 上的线程就会被唤醒，可以继续执行。

以下是 CountDownLatch 的一些关键方法：

  1. CountDownLatch(int count)： 构造方法，传入计数器的初始值。

  2. void countDown()： 计数器减一，表示一个线程完成了任务。

  3. void await()： 等待计数器变为零，阻塞当前线程。

  4. boolean await(long timeout, TimeUnit unit)： 在指定的时间内等待计数器变为零，超时后返回 true，否则返回 false。

以下是一个简单的示例，演示了 CountDownLatch 的基本用法：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int numThreads = 3;
        CountDownLatch latch = new CountDownLatch(numThreads);

        for (int i = 0; i < numThreads; i++) {
            new Thread(() -> {
                // 模拟线程执行任务
                System.out.println("Thread " + Thread.currentThread().getId() + " is executing.");
                latch.countDown(); // 任务完成，计数器减一
            }).start();
        }

        latch.await(); // 等待计数器变为零
        System.out.println("All threads have completed their tasks.");
    }
}

在这个示例中，创建了一个 CountDownLatch，并在多个线程中模拟执行任务，每个线程执行完任务后调用 countDown 方法。主线程通过 await 方法等待所有线程执行完任务后继续执行。这样，CountDownLatch 就实现了多个线程之间的协调。

CountDownLatch 的应用场景包括等待多个线程完成某个任务后再进行下一步操作、并行计算中等待多个计算任务完成、主线程等待多个子线程初始化完成等。

1.2 使用CountDownLatch模拟王者荣耀加载页面

package com.test;

import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author 曹见朋
 * @create 2023-11-12-15:38
 */
public class CountDownLatchTest {

    public static void main(String[] args) {

        ExecutorService executorService = Executors.newFixedThreadPool(5);

        CountDownLatch countDownLatch = new CountDownLatch(5);

        Random random = new Random();

        String[] all = new String[5];


        for (int i = 0; i < 5; i++) {
            int k=i;
            executorService.submit(()->{
                for (int j = 0; j <= 100; j++) {
                    try {
                        Thread.sleep(random.nextInt(100));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    all[k] = j+"%";
                    System.out.print("\r"+ Arrays.toString(all));
                }
                countDownLatch.countDown();
            });
        }


        try {
            System.out.println("玩家正在进入游戏......游戏即将开始......");
            System.out.println();
            countDownLatch.await();
            System.err.println("\n"+"\n"+"游戏开始!敌人还有3秒到达！请做好准备！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}

在这里插入图片描述

2. CyclicBarrier

2.1 简介

CyclicBarrier 是 Java 中并发包（java.util.concurrent）提供的另一种同步工具，用于在多线程环境中实现多个线程的同步点。与 CountDownLatch 类似，CyclicBarrier 也可以用于线程的协同，但其机制略有不同。

CyclicBarrier 的主要特点是可以重用。它允许一组线程相互等待，直到所有线程都达到某个同步点，然后继续执行。一旦所有线程达到同步点，CyclicBarrier 的内部计数器会被重置，并且所有线程可以继续执行下一轮同步。

以下是 CyclicBarrier 的一些关键方法：

  1. CyclicBarrier(int parties)： 构造方法，传入参与同步的线程数。

  2. int await()： 调用线程到达同步点，等待其他线程。当所有线程都调用了 await 方法后，它们就会被释放，并且 CyclicBarrier 的内部计数器会被重置。

  3. int await(long timeout, TimeUnit unit)： 在指定的时间内等待其他线程。如果在超时时间内没有所有线程都到达同步点，调用线程会被释放，并返回一个表示等待状态的值。

以下是一个简单的示例，演示了 CyclicBarrier 的基本用法：

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int numThreads = 3;
        CyclicBarrier barrier = new CyclicBarrier(numThreads, () -> {
            // 当所有线程都到达同步点时执行的动作
            System.out.println("All threads have reached the barrier.");
        });

        for (int i = 0; i < numThreads; i++) {
            new Thread(() -> {
                try {
                    // 模拟线程执行任务
                    System.out.println("Thread " + Thread.currentThread().getId() + " is executing.");
                    barrier.await(); // 等待其他线程到达同步点
                    System.out.println("Thread " + Thread.currentThread().getId() + " continues execution.");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

在这个示例中，创建了一个 CyclicBarrier，并在多个线程中模拟执行任务。每个线程执行完任务后调用 await 方法，等待其他线程到达同步点。一旦所有线程都到达同步点，就会执行在构造方法中传入的动作，并且所有线程会被释放，可以继续执行下一轮同步。

CyclicBarrier 的应用场景包括多个线程分阶段执行任务、多个线程分工合作执行任务等。

2.2 CyclicBarrier 模拟游戏多人联机对战场景

在游戏开发中，CyclicBarrier 可以用于实现多个玩家或角色在某个关键点进行同步，以确保所有玩家都准备好后再开始某个阶段的游戏。以下是一个典型的应用场景：

游戏多人联机对战场景：

假设有一个多人联机对战游戏，游戏中的每个玩家都需要准备好装备、选择角色等信息后，才能开始游戏。使用 CyclicBarrier 可以在游戏开始前创建一个同步点，确保所有玩家都准备就绪后才开始游戏。

package com.test.mythreadpool;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author 曹见朋
 * @create 2023-11-12-16:27
 */
public class CyclicBarrierTest {

    private static final int NUM_PLAYERS = 4;
    private static final CyclicBarrier gameStartBarrier = new CyclicBarrier(NUM_PLAYERS, () -> {
        System.out.println("All players are ready. Game starts!");
    });

    public static void main(String[] args) {
        for (int i = 0; i < NUM_PLAYERS; i++) {
            new Thread(() -> {
                // 模拟玩家准备工作
                System.out.println("Player " + Thread.currentThread().getId() + " is preparing.");
                try {
                    // 等待其他玩家准备
                    gameStartBarrier.await();
                    // 开始游戏
                    System.out.println("Player " + Thread.currentThread().getId() + " starts the game.");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

在这个例子中，CyclicBarrier 被用于创建一个同步点 gameStartBarrier，在这个同步点上，所有玩家等待，直到所有玩家都准备好后，执行了 gameStartBarrier.await() 后，所有玩家同时开始游戏。

这种应用场景确保了游戏开始前所有玩家的同步，避免了一些玩家在游戏开始后还在准备中的问题，提升了游戏的整体体验。

3. CyclicBarrier和CountDownLatch的区别是什么？

CyclicBarrier 和 CountDownLatch 都是Java并发包提供的用于多线程协同的工具，但它们有一些关键区别：

  1. 可重用性：

    • CyclicBarrier 是可重用的。一旦所有线程到达同步点，CyclicBarrier 的内部计数器会被重置，可以用于下一轮的同步。
    • CountDownLatch 是不可重用的。一旦计数器减为零，无法重新设置计数器，而且无法再次使用。

  2. 计数器递减：

    • CyclicBarrier 的计数器是递增的。线程调用 await 方法等待，计数器递增，直到计数器达到设定值时，所有等待的线程被唤醒。
    • CountDownLatch 的计数器是递减的。每次调用 countDown 方法，计数器减一，当计数器减为零时，等待的线程被唤醒。

  3. 等待状态：

    • 在 CyclicBarrier 中，等待的线程在同步点处被阻塞，一旦所有线程都到达同步点，它们被同时释放，继续执行下一步操作。
    • 在 CountDownLatch 中，等待的线程在计数器为零之前一直被阻塞，一旦计数器为零，所有等待的线程被唤醒，继续执行。

  4. 动作：

    • CyclicBarrier 允许在所有线程到达同步点时执行一个可选的动作（Runnable）。
    • CountDownLatch 不提供类似的机制。

下面是一个简单的比较例子：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

public class ComparisonExample {
    public static void main(String[] args) throws InterruptedException {
        int numThreads = 3;

        // CyclicBarrier 示例
        CyclicBarrier cyclicBarrier = new CyclicBarrier(numThreads, () -> {
            System.out.println("CyclicBarrier: All threads have reached the barrier.");
        });

        for (int i = 0; i < numThreads; i++) {
            new Thread(() -> {
                System.out.println("CyclicBarrier: Thread is performing a task.");
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }

        Thread.sleep(2000); // 等待线程执行完成

        // CountDownLatch 示例
        CountDownLatch countDownLatch = new CountDownLatch(numThreads);

        for (int i = 0; i < numThreads; i++) {
            new Thread(() -> {
                System.out.println("CountDownLatch: Thread is performing a task.");
                countDownLatch.countDown();
            }).start();
        }

        countDownLatch.await(); // 等待计数器为零

        System.out.println("CountDownLatch: All threads have completed their tasks.");
    }
}

在这个例子中，通过 CyclicBarrier 和 CountDownLatch 分别创建了两组线程，模拟了它们的使用方式。CyclicBarrier 在所有线程到达同步点时执行一个动作，而 CountDownLatch 在计数器为零时唤醒等待的线程。

最后，让我们以旅行团的情景来说明 CyclicBarrier 和 CountDownLatch 的区别：

  • CyclicBarrier（循环屏障）
    假设有一个旅行团，旅行中有多个景点需要游客参观。在出发前，导游告诉游客，每到一个景点，所有游客都需要等待其他游客到达后才能一起继续前进。导游设置了一个 CyclicBarrier，每个景点都是一个同步点。当游客到达一个景点后，他们调用 await 方法等待其他游客到达。一旦所有游客都到达，CyclicBarrier 就会打开，所有游客一起前往下一个景点。
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class TravelGroupWithCyclicBarrier {
    private static final int NUM_TOURISTS = 5;
    private static final CyclicBarrier arrivalBarrier = new CyclicBarrier(NUM_TOURISTS, () -> {
        System.out.println("All tourists have arrived. Moving to the next attraction.");
    });

    public static void main(String[] args) {
        for (int i = 0; i < NUM_TOURISTS; i++) {
            new Thread(() -> {
                // 游客到达当前景点
                System.out.println("Tourist " + Thread.currentThread().getId() + " has arrived.");
                try {
                    // 等待其他游客到达
                    arrivalBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
  • CountDownLatch
    现在，假设旅行团中的每个游客都有自己的一些准备工作，例如检查护照、购买旅行用品等。在出发前，导游告诉游客，所有准备工作完成后才能出发。导游设置了一个 CountDownLatch，初始计数器为旅客的数量。每个游客在完成准备工作后，调用 countDown 方法减少计数器。导游在等待计数器减为零后，就知道所有游客都准备好了，可以出发了。
import java.util.concurrent.CountDownLatch;

public class TravelGroupWithCountDownLatch {
    private static final int NUM_TOURISTS = 5;
    private static final CountDownLatch preparationLatch = new CountDownLatch(NUM_TOURISTS);

    public static void main(String[] args) {
        for (int i = 0; i < NUM_TOURISTS; i++) {
            new Thread(() -> {
                // 游客完成准备工作
                System.out.println("Tourist " + Thread.currentThread().getId() + " has completed preparations.");
                // 减少准备计数器
                preparationLatch.countDown();
            }).start();
        }

        try {
            // 等待所有游客完成准备工作
            preparationLatch.await();
            System.out.println("All tourists have completed preparations. Departing now!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
  • 区别总结
    • CyclicBarrier 适用于一组线程需要相互等待，达到同一点后再继续执行的场景，而且可以重复使用。
    • CountDownLatch 适用于一个或多个线程需要等待其他线程完成某个操作后再执行的场景，但它是一次性的，计数器归零后不能再次使用。

http://www.niftyadmin.cn/n/5174005.html

相关文章

node插件express（路由）的插件使用（二）——cookie 和 session的基本使用区别

node插件express（路由）的插件使用（二）——cookie 和 session的基本使用区别

文章目录 前言一、express 框架中的 cookie0、cookie的介绍和作用1. 设置cookie2.删除cookie3.获取cookie&#xff08;1&#xff09;安装cookie-parser&#xff08;2&#xff09;导入cookie-parser&#xff08;3&#xff09;注册中间件&#xff08;4&#xff09;获取cookie&…
阅读更多...
KubeSphere 社区双周报 | KubeSphere 3.4.1 发布 | 2023.10.27-11.09

KubeSphere 社区双周报 | KubeSphere 3.4.1 发布 | 2023.10.27-11.09

KubeSphere 社区双周报主要整理展示新增的贡献者名单和证书、新增的讲师证书以及两周内提交过 commit 的贡献者&#xff0c;并对近期重要的 PR 进行解析&#xff0c;同时还包含了线上/线下活动和布道推广等一系列社区动态。 本次双周报涵盖时间为&#xff1a;2023.10.27-2023.…
阅读更多...
按键精灵中的字符串常用的场景

按键精灵中的字符串常用的场景

在使用按键精灵编写脚本时&#xff0c;与字符串有关的场景有以下几种&#xff1a; 1. 用时间字符串记录脚本使用截止使用时间 Dim localTime "2023-11-12 00:15:14" Dim networkTime GetNetworkTime() TracePrint networkTime If networkTime > localTime The…
阅读更多...
GCC工具详解【Linux知识贩卖机】

GCC工具详解【Linux知识贩卖机】

很多人在喧嚣声中登场&#xff0c;也有少数人在静默中退出。 --单独中的洞见2 文章目录 简介程序到可执行文件链接动态链接和静态链接动态库和静态库动态库和静态库的打包打包静态库打包动态库选项 -static 总结 简介 GCC&#xff08;GNU Compiler Collection&#xff09; 是一…
阅读更多...
leetcode刷题日记:111. Minimum Depth of Binary Tree(二叉树的最小深度)

leetcode刷题日记:111. Minimum Depth of Binary Tree(二叉树的最小深度)

给我们一个二叉树&#xff0c;我们应该如何来求二叉树的最小深度呢&#xff1f; 二叉树的最小深度指的是叶子结点到所处的位置最小的&#xff0c;这就是二叉树的最小深度&#xff0c;也就是说我们要找的是离根结点最近的叶子结点。如果我们从根结点向下出发寻找叶子节点&#x…
阅读更多...
C语言 判断一个素数能被几个9整除

C语言 判断一个素数能被几个9整除

完整代码&#xff1a; // 判断一个素数能被几个9整除 //就是99...99%n0,n为那个素数 #include<stdio.h>int func(int n){//num是被除数就是99..9,i记录num有多少个9int num0,i0;//死循环while (1){i;numnum*109;//直到整除才跳出循环if (num%n0){//返回值为9的个数retu…
阅读更多...
【mysql】将逗号分割的字段内容转换为多行并group by

【mysql】将逗号分割的字段内容转换为多行并group by

先说需求&#xff1a; 公司想让我通过mysql导出一个报表&#xff0c;内容为公司每个人参加会议的次数&#xff0c;现在有一个会议表fusion_meeting&#xff0c;正常的逻辑是通过人员直接group by就可以得出结果&#xff0c;但是我们的参会人是通过逗号分割这种方式存在一个字段…
阅读更多...
照片放大软件 Topaz Gigapixel AI mac中文版简介

照片放大软件 Topaz Gigapixel AI mac中文版简介

Topaz Gigapixel AI mac是一款使用人工智能功能扩展图像的桌面应用程序&#xff0c;同时添加自然细节以获得惊人的效果。使用深度学习技术&#xff0c;A.I.Gigapixel™可以放大图像并填写其他调整大小的产品遗漏的细节&#xff0c;使用A.I.Gigapixel™&#xff0c;您可以裁剪照…
阅读更多...
最新文章

Copyright @ 2022~2023