五、CountDownLatch、CyclicBarrier和Semaphore的比较

最新推荐文章于 2023-07-01 08:12:02 发布
最新推荐文章于 2023-07-01 08:12:02 发布
阅读量497 收藏 1
点赞数
分类专栏： Java并发编程 文章标签： java thread countdowlatch 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovesman/article/details/104090394
版权

一、JMM模型与volatile详解
二、synchronized原理详解
三、AQS框架详解——AbstractQueuedSynchronizer
四、ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue和DelayQueue学习总结
五、CountDownLatch、CyclicBarrier和Semaphore的比较
java中interruptor理解与使用
Java线程的6种状态及切换
MESI协议：保证可见性，无法保证原子性

javadoc是这么描述它们的：

（1） CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
（2）CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.

从javadoc的描述可以得出：
（1）
CountDownLatch：一个或者多个线程，等待其他多个线程完成某件事情之后才能执行；
CyclicBarrier：多个线程互相等待，直到到达同一个同步点，再继续一起执行。
Semaphore：可以设置一个数字，表示同时可以执行的线程数量。
（2）
对于CountDownLatch来说，重点是“一个线程（多个线程）等待”，而其他的N个线程在完成“某件事情”之后，可以终止，也可以等待。 而对于CyclicBarrier，重点是多个线程，在任意一个线程没有完成，所有的线程都必须互相等待，然后继续一起执行。
（3）
CountDownLatch是计数器，线程完成一个记录一个，只不过计数不是递增而是递减，而CyclicBarrier更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。

一、CountDownLatch

可以使一个线程等待其他线程完成工作后再执行，例如zookeeper的分布式锁。

1、构造函数

 public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

count表示等待的线程数目，底层依然依赖AQS的state。

2、重要方法

public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

阻塞当前线程，直到count减小到0。

 public void countDown() {
        sync.releaseShared(1);
    }

count减小1。

3、CountDownLatch用法示例

举例：张三、李四、王五去餐馆吃饭，服务员需要等他们三个人到齐了之后才能开始；关键点是：一个服务员等待三个顾客

package com.ysy.countdownlatch;

import java.util.concurrent.CountDownLatch;

/**
 * @author 
 * @date 2020/6/17
 * CountDownLatch：等待其他几个线程把downlatch减小到0，再执行；
 * 张三、李四、王五去餐馆吃饭，服务员需要等他们三个人到齐了之后才能开始上菜。
 */
public class MainTest {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        /**
         * 三个人去餐馆吃饭
         * */
        createCustomerThread("张三", countDownLatch);
        createCustomerThread("李四", countDownLatch);
        createCustomerThread("王五", countDownLatch);

        Waitress waitress = new Waitress(countDownLatch);

        Thread thread = new Thread(waitress);

        thread.start();

    }

    private static void createCustomerThread(String name, CountDownLatch countDownLatch) {
        Customer customer = new Customer(countDownLatch, name);
        Thread thread = new Thread(customer);
        thread.start();
    }
}

package com.ysy.countdownlatch;

import java.util.concurrent.CountDownLatch;

/**
 * @author shanyangyang
 * @date 2020/6/17
 * Customer:
 * 去餐馆消费的人
 */
public class Customer implements Runnable {
    private CountDownLatch countDownLatch;
    /**
     * 餐馆消费者类
     */
    private String name;

    public Customer(CountDownLatch countDownLatch, String name) {
        this.countDownLatch = countDownLatch;
        this.name = name;
    }

    @Override public void run() {
        try {
            Thread.sleep((long)(Math.random() * 10000));
            System.out.println(name + "到达餐馆");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //数量减一
            countDownLatch.countDown();
        }
    }
}

package com.ysy.countdownlatch;

import java.util.concurrent.CountDownLatch;

/**
 * @author 
 * @date 2020/6/17
 * Waitress：
 * 餐馆服务员，等张三、李四、王五三个人到齐后开始上菜
 */
public class Waitress implements Runnable {
    private CountDownLatch countDownLatch;

    public Waitress(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override public void run() {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("服务员开始上菜");
    }
}

CyclicBarrier

阻塞一定数量的线程，直到最后一个线程也到达屏障时，才打开屏障，所有的线程继续执行。

1、构造函数

 public CyclicBarrier(int parties) {
        this(parties, null);
    }

  public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }

2、重要方法

 public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
    }

private int dowait(boolean timed, long nanos)
    throws InterruptedException, BrokenBarrierException,
           TimeoutException {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        final Generation g = generation;

        if (g.broken)
            throw new BrokenBarrierException();

        if (Thread.interrupted()) {
            breakBarrier();
            throw new InterruptedException();
        }

        int index = --count;
        if (index == 0) {  // tripped
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    command.run();
                ranAction = true;
                nextGeneration();
                return 0;
            } finally {
                if (!ranAction)
                    breakBarrier();
            }
        }

        // loop until tripped, broken, interrupted, or timed out
        for (;;) {
            try {
                if (!timed)
                    trip.await();
                else if (nanos > 0L)
                    nanos = trip.awaitNanos(nanos);
            } catch (InterruptedException ie) {
                if (g == generation && ! g.broken) {
                    breakBarrier();
                    throw ie;
                } else {
                    // We're about to finish waiting even if we had not
                    // been interrupted, so this interrupt is deemed to
                    // "belong" to subsequent execution.
                    Thread.currentThread().interrupt();
                }
            }

            if (g.broken)
                throw new BrokenBarrierException();

            if (g != generation)
                return index;

            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
        lock.unlock();
    }
}

3、CyclicBarrier使用实例

例子：张三、李四、王五和杨六去餐馆吃饭，他们去餐馆之后相互等待对方，等人齐了才能开饭。

package com.company;

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;

/**
 * @author 
 */
public class Main {

    public static void main(String[] args) throws InterruptedException {
        //创建线程池，避免手工显示创建线程
        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(4);


        CyclicBarrier cyclicBarrier = new CyclicBarrier(4);

	    PlayGame playGame1 = new PlayGame(cyclicBarrier,"张三");

        PlayGame playGame2 = new PlayGame(cyclicBarrier,"李四");

        PlayGame playGame3 = new PlayGame(cyclicBarrier,"王五");

        PlayGame playGame4 = new PlayGame(cyclicBarrier,"杨六");


        executorService.execute(playGame1);

        executorService.execute(playGame2);

        executorService.execute(playGame3);

        executorService.execute(playGame4);

        executorService.shutdown();

    }
}

package com.company;

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

/**
 * @author 
 * @date 2020/6/18
 */
public class PlayGame implements Runnable{
    private CyclicBarrier cyclicBarrier;
    private  String name;

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

    @Override
    public void run() {
        System.out.println(name+"到达餐厅，等人齐了开始吃饭");
        try {
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        } 
        System.out.println("人齐了大家开始吃饭");
    }
}

在这里插入图片描述

CyclicBarrier设置超时时间

cyclicBarrier.await(1000, TimeUnit.MILLISECONDS);

CyclicBarrier可以重用

三、Semaphore

Semaphore是信号量的意思，可以控制访问特定资源的线程数量，底层依赖AQS中的状态state。

1、构造函数

public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

permits表示线程的数量；

 public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

为true时表示公平锁，为false时表示非公平锁；

2、重要方法

  public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

获取许可；

  public void release() {
        sync.releaseShared(1);
    }

释放锁

可以看出底层实现依然是依赖我们前面所说的AQS框架。

3、Semaphore用法实例

张三、李四和王五去吃饭，但是餐馆只有两个位置，第三个到的人需要等前面的人把位置让出来

package com.company;

import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.Semaphore;

public class Main {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2);

        ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(2);

        Customer customer1 = new Customer(semaphore,"张三");

        Customer customer2 = new Customer(semaphore,"李四");

        Customer customer3 = new Customer(semaphore,"王五");

        scheduledExecutorService.execute(customer1);

        scheduledExecutorService.execute(customer2);

        scheduledExecutorService.execute(customer3);

        scheduledExecutorService.shutdown();
    }
}

package com.company;

import java.util.concurrent.Semaphore;


/**
 * @author 
 * @date 2020/6/18
 */
public class Customer implements Runnable{
    private Semaphore semaphore;
    private String name;

    public Customer(Semaphore semaphore, String name) {
        this.semaphore = semaphore;
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name+":先问一下餐馆有没有位置");
        try {
            semaphore.acquire();
            System.out.println(name+":有座位了，开始吃饭");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        semaphore.release();
        System.out.println(name+":我吃完了，把位置让出来");
    }
}

在这里插入图片描述

lovesman
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解
08-29
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解 Java并发编程是Java语言中的一种高级技术，用于处理多线程编程中的同步问题。Java 1.5中引入了几个高效的辅助类，包括CountDownLatch、...
Semaphore源码解析以及与CountDownLatch的对比
IT搬砖工在路上
06-03 550
写在前面 信号量，源码中的注释是这样写的 : A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each {@link #acquire} blocks if necessary until a permit is available, and then takes it. Each {@link #release} adds a permit, potentially releasing a blo
简述CyclicBarrier、CountDownLatch和Semaphore
米二的博客
08-02 1947
文章目录前言一. 概念篇1.1 CyclicBarrier1.2. CountDownLatch1.3. Semaphore二. 案例篇2.1. CyclicBarrier2.2. CountDownLatch2.3. Semaphore三. 深入篇3.1. CyclicBarrier3.2. CountDownLatch3.3. Semaphore3.4. CAS3.5. AQS 前言
CountDownLatch、CyclicBarrier、Semaphore的用法和区别
个人站点：javatv.net
04-04 1243
CountDownLatch CountDownLatch（也叫闭锁）是一个同步协助类，允许一个或多个线程等待，直到其他线程完成 操作集。 CountDownLatch 使用给定的计数值（count）初始化。await 方法会阻塞直到当前的计数值（count）由于 countDown 方法的调用达到 0，count 为 0 之后所有等待的线程都会被释放，并且随后对await方法的调用都会立即返回。 构造方法 //参数count为计数值 public CountDownLatch(int count) {};
CountDownLatch基本使用及原理
最新发布
qq_39939541的博客
07-01 3156
CountDownLatch是一个线程同步工具类，它可以让一个或多个线程等待其他线程完成某个任务后再继续执行。它通过一个计数器来实现，计数器的初始值可以设置为一个正整数，每当一个线程完成任务后，计数器的值就会减1，当计数器的值变为0时，所有等待的线程就会被唤醒。AbstractQueuedSynchronizer是一个用于构建锁和同步器的基类，它提供了一个框架，供子类重写并实现自己的同步逻辑。AQS内部维护了一个FIFO的等待队列，用于管理等待获取锁的线程，并提供了一些方法供子类操作这个队列。
JAVA面试考点—— CountDownLatch和Semaphore的区别和底层原理
一直走，不要回头
10-22 1183
CountDownLatch和Semaphore使用场景https://segmentfault.com/a/1190000038672250 CountDownLatch、CyclicBarrier、Semaphore 用法总结https://segmentfault.com/a/1190000012234469 CountDownLatch 表示计数器，可以给CountDownLatch设置一个数字 一个线程调用CountDownLatch的await()方法，将会阻塞 其他线程可以调用C
Java并发编程一CountDownLatch、CyclicBarrier、Semaphore初使用
12-23
Java并发编程一CountDownLatch、CyclicBarrier、Semaphore初使用 CountDownLatch、CyclicBarrier、Semaphore这些线程协作工具类是基于AQS的，看完这篇博客后可以去看下面这篇博客，了解它们是如何实现的。 Java并发...
CountDownLatch、CyclicBarrier、Semaphore.md
06-07
java 高并发应用场景
CountDownLatch、Semaphore等4大并发工具类详解
11-15
本文将详细介绍 Java 并发工具类的四大类：CountDownLatch、Semaphore、CyclicBarrier 和 Phaser，及其应用场景和使用方法。 CountDownLatch CountDownLatch 是一个同步的辅助类，允许一个或多个线程，等待其他一...
CountDownLatch和Semaphore的区别和底层原理
m0_70734549的博客
07-25 661
CountDownLatch和Semaphore的区别和底层原理
Semaphore和CountDownLatch的区别，实例说明Semaphore
weixin_71220035的博客
03-22 507
Semaphore和CountDownLatch的区别
Java笔记-对CountDownLatch的理解（对比Qt中的QSemaphore）含实例
IT1995的博客
12-01 798
首先在CountDownLatch，这个东西基本上和信号量是一样的，这个CountDownLatch要设置一个初值，这个值一般是个正值，可以对这个CountDownLatch进行countDown()也就是减1，当减少为0时，await()函数就会从阻塞变成就绪态。 下面是Java代码，举个例子，此例子来源于博客园大神，3个工人干活，3个都干完后，老版才开始检查工作，运行截图如下： 源码如下： Boss.java package cn.it1995; import java.util..
Semaphore、CyclicBarrier和CountDownLatch三者的区别
ALiangXLogic的博客
04-09 589
Semaphore 首先我们来看看Semaphore，中文名称信号量 我们来看看它的最常使用的方式 Semaphore semaphore = new Semaphore(1); 我们通过这个构造方法，传进去一个int型变量，这就是通过这个int型变量，来限制线程所能使用的资源，当我们通过semaphore.acquire();方法来阻塞线程的执行,比如我下面这种情况 public class demo1 { Semaphore semaphore1 = new Semaphore(1);
多线程 - CountDownLatch 和 Semaphore
学无止境
03-27 514
CountDownLatch 和 Semaphore 都是 Java 多线程编程中的同步工具，用于控制线程的执行顺序和对共享资源的访问控制。CountDownLatch 是一个计数器，允许一个或多个线程等待其他线程完成操作后再执行。在 CountDownLatch 初始化时设置一个计数器，每个线程完成任务后将计数器减 1，当计数器变为 0 时，等待的线程将被唤醒。Semaphore 是一个信号量，用于控制同时访问共享资源的线程数量。
高并发编程系列：4大并发工具类的功能、原理、以及应用场景
LMAKE_nbsp的博客
11-12 2434
通常我们所说的并发包也就是java.util.concurrent，集中了Java并发工具类和并发容器等，今天主要介绍Java并发编程的工具类，我先从Java并发工具包谈起。 01 — 并发工具包涵盖范围 1.并发工具类 提供了比synchronized更加高级的各种同步结构：包括CountDownLatch、CyclicBarrier、Semaphore等，可以实现更加丰富的多线程操作...
CountDownLatch、CyclicBarrier、Semaphore的区别
qq_40262372的博客
07-24 221
CountDownLatch原理 减法计数器，CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每个线程完成自己任务后，计数器的值就会减一。当计数器的值为0的时候，表示所有的线程都已经完成任务，然后在CountDownLatch上等待的线程就可以恢复接下来的任务了。 经典用法： 1.某个线程在开始运行前等待n个线程执行前完毕。将CountDwonLatch的计数器初始化后，每当一个任务线程执行完毕后...
Java并发编程之CountDownLatch
zdl_csdn的博客
08-16 212
Java并发编程之CountDownLatch **CountDownLatch简介：**countdownlatch是在jdk1.5时被引入，存在于java.util.cucurrent包下，被同时引入的 voncurrentHashMap和BlockingQueue。 countDownLatch用来使一个线程等待其他线程各自执行完毕后再执行。内部是通过维护一个volatile修饰的一个关键字来实现的，其值表示线程的数量，当一个线程执行完毕后，该变量值就自动减1，只有当该值为0时，代表所有线程都已执行完
CountDownLatch类的使用和优点
weixin_41429524的博客
05-16 703
作用：允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。 一、CountDownLatch中的方法 CountDownLatch(int count)：构造器方法，参数为计数初始化值 void await()：导致当前线程等到锁存器计数为零，除非线程是interrupted boolean await(long timeout,TimeUnit unit)：是当前线程等待直到锁存器计数到零为止，除非线程是interrupted或指定等待的时间过去。 void countDow..
CountDownLatch、CyclicBarrier、Semaphore区别和使⽤场景
06-08
CountDownLatch、CyclicBarrier、Semaphore都是Java中用于多线程编程的同步工具类，但它们有不同的作用和使用场景。 1. CountDownLatch CountDownLatch（倒计时门闩）是一个同步工具类，它允许一个或多个线程等待...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值