Semaphore、CountdownLatch、CyclicBarrier详解

最新推荐文章于 2023-10-13 08:00:00 发布
最新推荐文章于 2023-10-13 08:00:00 发布
阅读量726 收藏 7
点赞数 4
分类专栏： Java并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZSA222/article/details/123609827
版权

文章目录

1.Semaphore

信号量，用来限制能同时访问共享资源的线程上限。

1.1 基本使用

/**
 * @ClassName SemaphoreTest
 * @author: shouanzh
 * @Description 信号量，用来限制能同时访问共享资源的线程上限。
 * @date 2022/3/20 11:32
 */
@Slf4j
public class SemaphoreTest {

    public static void main(String[] args) {

        // 1. 创建 Semaphore 对象
        Semaphore semaphore = new Semaphore(3); // 限制上限为3

        // 2. 10个线程同时运行
        for (int i = 0; i < 10; i++) {

            new Thread(()->{
                try {
                    // 3.获得此信号量
                    semaphore.acquire();
                    log.debug("获得信号量");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 4.释放信号量
                    semaphore.release();
                }
            },"t" + i).start();

        }

    }

}

运行结果

// 每次运行三个线程
2022-03-20 11:45:05 [t0] - 获得信号量
2022-03-20 11:45:05 [t2] - 获得信号量
2022-03-20 11:45:05 [t1] - 获得信号量

2022-03-20 11:45:07 [t3] - 获得信号量
2022-03-20 11:45:07 [t4] - 获得信号量
2022-03-20 11:45:07 [t5] - 获得信号量

2022-03-20 11:45:09 [t6] - 获得信号量
2022-03-20 11:45:09 [t7] - 获得信号量
2022-03-20 11:45:09 [t8] - 获得信号量

2022-03-20 11:45:11 [t9] - 获得信号量

Process finished with exit code 0

1.2 Semaphore原理-图解流程

加锁解锁流程

Semaphore 有点像一个停车场，permits 就好像停车位数量，当线程获得了 permits 就像 是获得了停车位，然后停车场显示空余车位减一

刚开始，permits (state)为3，这时5个线程来获取资源
在这里插入图片描述
假设其中 Thread-1, Thread-2, Thread-4 CAS竞争成功,而 Thread-0 和 Thread-3竞争失 败,进入AQS 队列park阻塞

在这里插入图片描述

这时 Thread-4释放了 permits,状态如下
在这里插入图片描述

接下来 Thread-0竞争成功，permits 再次设置为0，设置自己为 head节点，断开原来的 head 节点， unpark接下来的 Thread-3 节点，但由于 permits 是0，因此 Thread-3 在尝试 不成功后再次进入 park状态

在这里插入图片描述

1.3 Semaphore原理-源码分析

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = -2694183684443567898L;
    NonfairSync(int permits) {
        // permits 即 state
        super(permits);
    }

    // Semaphore 方法, 方便阅读, 放在此处
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    
    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

    // 尝试获得共享锁
    protected int tryAcquireShared(int acquires) {
        return nonfairTryAcquireShared(acquires);
    }

    // Sync 继承过来的方法, 方便阅读, 放在此处
    final int nonfairTryAcquireShared(int acquires) {
        for (;;) {
            int available = getState();
            int remaining = available - acquires;
            if (
                // 如果许可已经用完, 返回负数, 表示获取失败, 进入 doAcquireSharedInterruptibly
                    remaining < 0 ||
                            // 如果 cas 重试成功, 返回正数, 表示获取成功
                            compareAndSetState(available, remaining)
            ) {
                return remaining;
            }
        }
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    // 再次尝试获取许可
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        // 成功后本线程出队（AQS）, 所在 Node设置为 head
                        // 如果 head.waitStatus == Node.SIGNAL ==> 0 成功, 下一个节点 unpark
                        // 如果 head.waitStatus == 0 ==> Node.PROPAGATE
					  // r 表示可用资源数, 为 0 则不会继续传播
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                // 不成功, 设置上一个节点 waitStatus = Node.SIGNAL, 下轮进入 park 阻塞
                if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    // Semaphore 方法, 方便阅读, 放在此处
    public void release() {
        sync.releaseShared(1);
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

    // Sync 继承过来的方法, 方便阅读, 放在此处
    protected final boolean tryReleaseShared(int releases) {
        for (;;) {
            int current = getState();
            int next = current + releases;
            if (next < current) // overflow
                throw new Error("Maximum permit count exceeded");
            if (compareAndSetState(current, next))
                return true;
        }
    }
    
    private void doReleaseShared() {
        /*
         * Ensure that a release propagates, even if there are other
         * in-progress acquires/releases.  This proceeds in the usual
         * way of trying to unparkSuccessor of head if it needs
         * signal. But if it does not, status is set to PROPAGATE to
         * ensure that upon release, propagation continues.
         * Additionally, we must loop in case a new node is added
         * while we are doing this. Also, unlike other uses of
         * unparkSuccessor, we need to know if CAS to reset status
         * fails, if so rechecking.
         */
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                     // 唤醒后续节点
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }
}

2.CountdownLatch

用来进行线程同步协作，它允许一个或多个线程一直等待，直到其他线程的操作执行完毕再执行。

其中构造参数用来初始化等待计数值，await()用来等待计数归零，countDown()用来让计数减一

CountDownLatch 是共享锁的一种实现,它默认构造 AQS 的 state 值为 count。当线程使用 countDown方法时,其实使用了 tryReleaseShared 方法以CAS 的操作来减少 state ,直至 state 为 0 就代表所有的线程都调用了countDown方法。当调用 await 方法的时候，如果 state 不为0，就代表仍然有线程没有调用 countDown 方法，那么就把已经调用过 await 的线程都放入阻塞队列 Park ,并自旋 CAS 判断 state == 0，直至最后一个线程调用了 countDown ，使得 state == 0，于是阻塞的线程便判断成功，全部往下执行。

代码举例

/**
 * CountDownLatchTest 用来进行线程同步协作，它允许一个或多个线程一直等待，
 * 直到其他线程的操作执行完毕再执行。
 */
@Slf4j
public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        method3();
    }

    /**
     * 基本使用
     * @throws InterruptedException
     */
    public static void method1() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(3);

        new Thread(() -> {
            log.debug("begin...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
            log.debug("end...");
        },"t1").start();

        new Thread(() -> {
            log.debug("begin...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
            log.debug("end...");
        },"t2").start();

        new Thread(() -> {
            log.debug("begin...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
            log.debug("end...");
        },"t3").start();

        log.debug("await...");
        countDownLatch.await();
        log.debug("await end...");

        /**
         * 2022-03-20 13:07:14 [t3] - begin...
         * 2022-03-20 13:07:14 [main] - await...
         * 2022-03-20 13:07:14 [t1] - begin...
         * 2022-03-20 13:07:14 [t2] - begin...
         * 2022-03-20 13:07:15 [t1] - end...
         * 2022-03-20 13:07:16 [t2] - end...
         * 2022-03-20 13:07:17 [t3] - end...
         * 2022-03-20 13:07:17 [main] - await end...
         *
         * Process finished with exit code 0
         */
    }

    /**
     * 改进
     */
    public static void method2() {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        ExecutorService executorService = Executors.newFixedThreadPool(4);

        executorService.submit(() -> {
            log.info("t1 start ...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
            log.info("t1 end ...{}", countDownLatch.getCount());
        });

        executorService.submit(() -> {
            log.info("t2 start ...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
            log.info("t2 end ...{}", countDownLatch.getCount());
        });

        executorService.submit(() -> {
            log.info("t3 start ...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
            log.info("t3 end ...{}", countDownLatch.getCount());
        });

        // 等待其它线程执行完成
        executorService.submit(() -> {
            log.info("main wait ...");
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("main wait end ...");
            executorService.shutdown();
        });

        /**
         * 2022-03-20 13:50:20 [pool-1-thread-2] - t2 start ...
         * 2022-03-20 13:50:20 [pool-1-thread-3] - t3 start ...
         * 2022-03-20 13:50:20 [pool-1-thread-1] - t1 start ...
         * 2022-03-20 13:50:20 [pool-1-thread-4] - main wait ...
         * 2022-03-20 13:50:21 [pool-1-thread-1] - t1 end ...2
         * 2022-03-20 13:50:22 [pool-1-thread-2] - t2 end ...1
         * 2022-03-20 13:50:23 [pool-1-thread-3] - t3 end ...0
         * 2022-03-20 13:50:23 [pool-1-thread-4] - main wait end ...
         *
         * Process finished with exit code 0
         */
    }

    /**
     * 用来进行线程同步协作，它允许一个或多个线程一直等待，直到其他线程的操作执行完毕再执行。
     * @throws InterruptedException
     */
    public static void method3() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(10);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        String[] all = new String[10];
        Random random = new Random();
        for(int i = 0; i < 10; i++) {
            int id = i;
            executorService.submit(() -> {
                for (int j = 0; j <= 100; j++) {
                    try {
                        Thread.sleep(random.nextInt(100));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    all[id] = j + "%";
                    System.out.print("\r" + Arrays.toString(all));
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        System.out.println();
        log.debug("游戏开始...");
        executorService.shutdown();

        /**
         * [100%, 100%, 100%, 100%, 100%, 100%, 100%, 100%, 100%, 100%]
         * 2022-03-20 14:01:34 [main] - 游戏开始...
         *
         * Process finished with exit code 0
         */
    }

}

3.CyclicBarrier

循环栅栏，用来进行线程协作，等待线程满足某个计数。构造时设置『计数个数』，每个线程执行到某个需要“同步”的时刻调用 await() 方法进行等待，当等待的线程数满足『计数个数』时，继续执行。跟 CountdownLatch 一样，但这个可以重用。

/**
 * @ClassName CyclicBarrierTest
 * @author: shouanzh
 * @Description 循环栅栏，用来进行线程协作，等待线程满足某个计数。
 * 构造时设置『计数个数』，每个线程执行到某个需要“同步”的时刻调用 await() 方法进行等待，
 * 当等待的线程数满足『计数个数』时，继续执行。跟 CountdownLatch 一样，但这个可以重用。
 * @date 2022/3/20 14:38
 */
@Slf4j
public class CyclicBarrierTest {

    public static void main(String[] args) {

        ExecutorService executorService = Executors.newFixedThreadPool(2);

        CyclicBarrier cyclicBarrier = new CyclicBarrier(2, () -> {
            log.info("task1,task2 finish ...");
        });

        for(int i = 0; i < 3; i++) {
            executorService.submit(() -> {
                log.info("task1 begin ...");
                try {
                    Thread.sleep(1000);
                    cyclicBarrier.await(); // 2-1 = 1
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });

            executorService.submit(() -> {
                log.info("task2 begin ...");
                try {
                    Thread.sleep(2000);
                    cyclicBarrier.await(); // 1-1 = 0
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }

        executorService.shutdown();
    }

}

运行结果

2022-03-20 14:52:06 [pool-1-thread-2] - task2 begin ...
2022-03-20 14:52:06 [pool-1-thread-1] - task1 begin ...
2022-03-20 14:52:08 [pool-1-thread-2] - task1,task2 finish ...
2022-03-20 14:52:08 [pool-1-thread-2] - task1 begin ...
2022-03-20 14:52:08 [pool-1-thread-1] - task2 begin ...
2022-03-20 14:52:10 [pool-1-thread-1] - task1,task2 finish ...
2022-03-20 14:52:10 [pool-1-thread-1] - task1 begin ...
2022-03-20 14:52:10 [pool-1-thread-2] - task2 begin ...
2022-03-20 14:52:12 [pool-1-thread-2] - task1,task2 finish ...

Process finished with exit code 0
Zhang_960110
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程一CountDownLatch、CyclicBarrier、Semaphore初使用
12-23
Java并发编程一CountDownLatch、CyclicBarrier、Semaphore初使用 CountDownLatch、CyclicBarrier、Semaphore这些线程协作工具类是基于AQS的，看完这篇博客后可以去看下面这篇博客，了解它们是如何实现的。 Java并发之AQS详解 CountDownLatch CountDownLatch可以实现一个线程等待多个线程、多个线程等待一个线程、多个线程等待多个线程（这里不涉及）。 我们首先来看看怎么实现一个线程等待多个线程吧。 工厂中，对产品需要进行质检，5个工人进行检查，所有人都认为通过，这个产品才算通过。 代码： packag
Java并发编程：CountDownLatch、CyclicBarrier和Semaphore
小单的博客专栏
02-07 507
在java 1.5中，提供了一些非常有用的辅助类来帮助我们进行并发编程，比如CountDownLatch，CyclicBarrier和Semaphore，今天我们就来学习一下这三个辅助类的用法。 以下是本文目录大纲： 一.CountDownLatch用法 二.CyclicBarrier用法 三.Semaphore用法 若有不正之处请多多谅解，并欢迎批评指正。 一.CountDownLatch用法 ...
CountDownLatch、CyclicBarrier、semaphore
星坠竹空
09-13 1366
CountDownLatch中调用await方法线程需要等待所有调用countDown方法的线程执行，这就很适合一个业务需要一些准备条件，等准备条件准备好之后再继续执行，如果一些复杂的聚合查询，还有一些类似于广播消息的功能。
CountDownLatch、CyclicBarrier和Semaphore
FYHannnnnn的博客
08-10 257
　在java 1.5中，提供了一些非常有用的辅助类来帮助我们进行并发编程，比如CountDownLatch，CyclicBarrier和Semaphore，今天我们就来学习一下这三个辅助类的用法。 　　以下是本文目录大纲： 　　一.CountDownLatch用法 　　二.CyclicBarrier用法 　　三.Semaphore用法 一.CountDownLatch用法 　　CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一
java基础编程60题之50
叨叨令
07-20 150
 /*      * 设计 4 个线程,其中两个线程每次对 j 增加 1,另外两个线程对 j 每次减少 1.写出程序.                    以下程序使用内部类实现线程 ,对 j 增减的时候没有考虑顺序问题 .      */ package com.xijiaopractice; public class Test50 { /* * 设计 4 个线程,其中两个线程每次...
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解
08-29
主要介绍了Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解的相关资料,需要的朋友可以参考下
java并发工具包详解
09-08
12. 闭锁 CountDownLatch 13. 栅栏 CyclicBarrier 14. 交换机 Exchanger 15. 信号量 Semaphore 16. 执行器服务 ExecutorService 17. 线程池执行者 ThreadPoolExecutor 18. 定时执行者服务 ScheduledExecutorService ...
详解java多线程的同步控制
01-20
目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ReadWriteLock倒计数器 CountDownLatch循环栅栏 CyclicBarrier信号量 Semaphore 线程安全 Thread Safety JMM JMM(Java Memory Model)是一种基于计算机内存...
Java并发编程原理与实战
08-14
CountDownLatch,CyclicBarrier,Semaphore源码解析.mp4 提前完成任务之FutureTask使用.mp4 Future设计模式实现（实现类似于JDK提供的Future）.mp4 Future源码解读.mp4 ForkJoin框架详解.mp4 同步容器与并发容器.mp4 ...
CountDownLatch、CyclicBarrier和Semaphore 使用示例及原理
一枝花算不算浪漫的专栏
12-16 1065
CountDownLatch CountDownLatch用户监听某些初始化操作，并且线程进行阻塞，等初始化执行完毕后，通知主线程继续工作执行。 CountDownLatch 使用示例 使用示例，线程t3 要等待t1和t2执行完毕才执行： /** * @Description: CountDownLatch 等待和唤醒 * @Author: wangmeng * @Date: 2018/12...
并发包下常见的同步工具类详解(CountDownLatch,CyclicBarrier,Semaphore)
dcnmm48064的专栏
09-25 243
目录 1. 前言 2. 闭锁CountDownLatch 2.1 CountDownLatch功能简介 2.2 使用CountDownLatch 2.3 CountDownLatch原理浅析 3.循环屏障CyclicBarrier ...
CountDownLatch、CyclicBarrier、Semaphore详解
Lizhj的博客
08-08 479
目录 CountDownLatch 简介 用法 原理及源码分析 CyclicBarrier 简介 用法 原理及源码分析 Semaphore 简介 用法 原理及源码分析 CountDownLatch 简介 CountDownLatch是 JDK 提供的并发流程控制的工具类，它是在 java.util.concurrent 包下，在 JDK1.5 以后加入，用来进行同步协作，等待所有线程完成倒计时。其中构造函数用来初始化等待计数值，await()用来等待计数归零，countDow.
Java并发编程工具类：CountDownLatch、CyclicBarrier、Semaphore
zp的博客
07-31 869
在jdk5中，java提供了一些非常有用的辅助工具类，包括CountDownLatch和CyclicBarrier(两者都可以实现线程之间的通信)、Semaphore(控制方法被线程访问的数量)，他们三者都依赖于AQS实现，都是共享锁。今天我们就来学习一下这四个辅助类的用法。 1、CountDownLatch        CountDownLatch基于AQS实现，它由共享锁实现：只要cou...
Java并发编程第9讲——CountDownLatch、CyclicBarrier和Semaphore（万字详解）
最新发布
让~学习~成为一种习惯（橡 皮 人の技术博客）
10-13 799
在JDK的并发包（JUC）里提供了几个非常有用的并发工具类。CountDownLatch、CyclicBarrier和Samaphore工具类提供了一种并发流程控制的手段，这同样也是面试和工作中的一个重要知识点，本文将从它们的定义、常用方法、代码示例及核心源码的分析等几个要点详细介绍一下。
Semaphore，CountDownLatch，CyclicBarrier
Mark Down Here
02-18 260
1、atomic包的原理及分析概论： CountDownLatch是一个计数器闭锁，主要的功能就是通过await()方法来阻塞住当前线程，然后等待计数器减少到0了，再唤起这些线程继续执行。 这个类里主要有两个方法，一个是向下减计数器的方法countdown()； Semaphore与CountDownLatch相似，不同的地方在于Semaphore的值被获取到后是可以释放的，并不像CountDown
countDownLatch、cyclicBarrier、semaphore使用详解
qq_250161537
09-26 401
文章目录前言countDownLatchcyclicBarriersemaphore结尾 前言 在前面两篇中介绍了AQS的同步队列、条件队列的源码实现，这一篇则是来看一下JUC中主要的三个并发工具类：countDownLatch、cyclicBarrier、semaphore。本文不会像之前两篇文章那样从源码角度展开，而是结合工具的API，来看一下这些工具类的使用方法以及场景。 countDownLatch countDownLatch我们可以理解为是一个计数器，计数器的初始值是线程的可执行的次数（这个实际
CountDownLatch CyclicBarrier
08-30
- *2* *3* [JUC多线程：CountDownLatch、CyclicBarrier、Semaphore同步器原理总结](https://blog.csdn.net/a745233700/article/details/120688546)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值