CountDownLatch源码的理解

最新推荐文章于 2024-07-14 11:00:49 发布
最新推荐文章于 2024-07-14 11:00:49 发布
阅读量1.5k 收藏
点赞数 1
分类专栏： 源码理解 文章标签： Java源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26411333/article/details/51416373
版权

CountDownLatch源码的理解

设计理念

CountDownLatch对线程的阻塞、释放是基于队列+计数器来实现的。

简单的例子说明

现在有如下代码：

public static void main(String[] args) {
    final CountDownLatch latch = new CountDownLatch(2);

    new Thread(){
        public void run() {
            try {
                System.out.println("线程1执行");
                Thread.sleep(5000);
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
    }.start();

    new Thread(){
        public void run() {
            try {
                System.out.println("线程2执行");
                Thread.sleep(3000);
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
    }.start();

    new Thread(){
        public void run() {
            try {
                System.out.println("线程3阻塞");
                latch.await();
                System.out.println("线程3继续执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
    }.start();

    try {
        Thread.sleep(1000);
        System.out.println("主线程线程阻塞");
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("主线程继续执行");
}

运行后的效果

线程1执行
线程2执行
线程3阻塞
主线程线程阻塞
线程3继续执行
主线程继续执行

结果说明：当latch中的计数器变为0时，调用await()的线程会继续执行，继续执行的顺序跟调用await()的先后有关。

队列+计数器的说明

计数器的简单说明

为了简化流程图，假设只有一个子线程调用了countDown()方法，只有主线程调用到了await()方法
这里写图片描述
上面的流程图只是说明计数器对各个线程的影响，个人不才，实在是画不出多线程+队列的的流程图。

队列的简单说明

每个线程调用await()，会向队列中添加一个node,拿刚才的代码说明：
1. 线程3调用await()，会在head和面添加一个node1(Head是自动生成的)

Created with Raphaël 2.1.0 Head node1-线程3
  1. 主线程线程调用await()，会在已有的队列中添加一个node2
Created with Raphaël 2.1.0 Head node1-线程3 node2-主线程
  1. 当计数器为0，各个线程被唤醒的时候，会判断线程对应node的前一个节点是否是Head，如果是Head，将当前的node设置为Head，再次唤醒线程。如果不是Head，继续挂起。对于上述代码：
    • 假如唤醒线程的时候，主线程首先执行：
      这里写图片描述
    • 假如唤醒线程的时候，线程3首先执行：
      这里写图片描述

以上这些流程图只是为了将单个功能更形象的表现出来，如果要完全理解，还是要回到源码中看逻辑

代码注释

CountDownLatch 里面的代码

public class CountDownLatch {

    //AbstractQueuedSynchronizer的具体类，真正控制线程的操作在这里实现
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        //构造方法，设置state,这里理解为设置计数器的大小
        Sync(int count) {
            setState(count);
        }

        //获取state,这里理解为获取计数器的大小
        int getCount() {
            return getState();
        }

        //尝试获取所，如果计数器的大小为0，返回1；
                    //大小不为0，返回-1
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

        //尝试释放锁
        protected boolean tryReleaseShared(int releases) {
            //开启自旋
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    //如果锁已经全部释放了，返回false
                    return false;
                int nextc = c-1;
                //通过CAS,更新计数器的大小
                if (compareAndSetState(c, nextc))
                    //释放一个锁（也就是计数器-1）以后，如果再也没有锁(计数器为0)，返回true,如果还有锁（计数器不为0），返回false
                    return nextc == 0;
            }
        }
    }

    private final Sync sync;

    //构造方法，计数器实际上是AbstractQueuedSynchronizer具体类的state
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

    //阻塞线程，等待计数器为0，
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    //阻塞线程，等待计数器为0，或者超过给定的时间
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    //计数器的大小减去1
    public void countDown() {
        sync.releaseShared(1);
    }

    //获取计数器的大小
    public long getCount() {
        return sync.getCount();
    }

    //不解释
    public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }
}

AbstractQueuedSynchronizer中有关await()中的部分代码

//await()中实际上是调用该方法
public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    //处理异常
    if (Thread.interrupted())
        throw new InterruptedException();
    //尝试获取锁，在这里，是调用CountDownLatch当中AbstractQueuedSynchronizer具体类中重写的方法
    //计数器大小为0，返回1；否则为-1；
    if (tryAcquireShared(arg) < 0)
        //计数器大小不为0，执行该方法
        doAcquireSharedInterruptibly(arg);
}

//计数器不为0时，调用该方法
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    //向队列中添加一个节点，(如果当前队列没有head,先创建head,再添加node)
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        //开启自旋，如果计数器为0，会结束自旋
        for (;;) {
            //获取当前node的前一个node
            final Node p = node.predecessor();
            //判断当前node是不是第一个node
            if (p == head) {
                //如果是第一个node，查看计数器是否为0
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    //计数器为0，说明所有的锁都释放了

                    //将当前的node设置为head,也就是将队列中第一个node设置为head，同时也会唤醒挂起的线程
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    //该方执行完毕，调用await()的线程可以继续执行
                    return;
                }
            }
            //将调用await()的线程挂起
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

AbstractQueuedSynchronizer中有关countDown()中的部分代码

//countDown()实际上调用的是该方法
public final boolean releaseShared(int arg) {
    //尝试释放锁，在这里，是调用CountDownLatch当中AbstractQueuedSynchronizer具体类中重写的方法
    //计数器-1，返回true,计数器大小没变，返回false
    if (tryReleaseShared(arg)) {
        //计数器大小-1，进入判断内部

        doReleaseShared();
        return true;
    }
    return false;
}

//计数器-1后，调用该方法
private void doReleaseShared() {
    //开启自旋
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    //使用continue，是为了确保Status的状态一定会修改成功
                    continue;            // loop to recheck cases
                //唤醒挂起的线程，也就是doAcquireSharedInterruptibly（）当中的自旋执行一次，可能再次挂起或者结束
                unparkSuccessor(h);
            }
            //唤醒线程后，head值改变的话，更新Status为PROPAGATE
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                //确保Status一定会修改成功
                continue;                // loop on failed CAS
        }
        //判读head是否更换（唤醒挂起的线程，有可能将head更新，也可能不更新）
        if (h == head)                   // loop if head changed
            //在这里，可以粗略的理解为：如果唤醒线程后，该线程仍然挂起，结束该方法的自旋
            break;

        //如果head改变，继续自旋，这样，就会调用compareAndSetWaitStatus(h, 0, Node.PROPAGATE)
    }
}

结语

上文中没有分析await(long timeout, TimeUnit unit)，留给各位Monkey去分析，顺便练习下看源码的能力。
看了这么多的分析，不要忘了CountDownLatch的作用：
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
简答说明：等待相应的线程结束后再去执行相关的代码。
源码作者：Doug Lea

转载请标明出处：http://blog.csdn.net/qq_26411333/article/details/51416373

尹凯文
关注
专栏目录
CountDownLatch源码解析
IT搬砖工在路上
05-30 604
目录总体介绍同步器的实现await方法countDown方法总结 总体介绍 一个同步器：能够让一个或者多个线程等待等待某个条件的到来再继续执行。 大家可以把CountDownLatch初始化的值认为是有N道门，刚开始是线程调用await方法发现门关着的，所以就只有等待。而外界条件的变化是通过countDown来实现，可以认为countDown一次就是打开一道门，当countDown的次数为N时，则全部的门打开，则刚才在await处等待的线程将继续执行任务。 看下具体的代码实现： public class
基于java8分析CountDownLatch源码
epiccic3的博客
07-06 228
ReentrantLock和ReentrantReadWriteLock都实现interface接口，内部又继承AbstractQueuedSynchronizer。而CountDownLatch是JUC中提供的一个多线程间协同的工具类，并没有实现interface接口，只在内部继承实现AQS。 CountDownLatch主要处理：主线程将某个大任务切分成数个小任务，由多个线程处理小任务，而主线程阻塞直到所有任务完成后，主线程再处理接下来的任务。即：处理一个线程与多个线程间的协同问题。 CountDo
CountDownLatch 源码
纸上得来终觉浅，绝知此事要躬行
07-03 331
state是一个volatile类型的变量，保证了对它的读写操作的可见性，以及禁止了指令重排序，从而确保了线程之间对state的操作是正确的和可靠的。
关于CountDownLatch的底层源码和闭坑指南，只看这一篇就够了！！
最新发布
likang_1167的博客
07-14 792
关于CountDownLatch的底层源码和闭坑指南，只看这一篇就够了！！
CountDownLatch源码
我的博客
06-22 673
CountDownLatch是依赖AQS完成的线程阻塞和唤醒，利用AQS的共享锁完成锁的多线程获取和释放。 CountDownLatch 使用了共享锁模式。CountDownLatch 使用一个内部类 Sync来实现CountDownLatch的同步控制，而Sync是AQS的一个实现类，它使用AQS的状态（state）来表示count。 用给定的计数初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await() 方法会一直受阻塞。之后，会释放所有
CountDownLatch源码-JUC线程同步工具2
mayongzhan_csdn的专栏
07-13 882
CountDownLatch源码-JUC线程同步工具2 上篇博文将的线程同步工具信号量Semaphore源码 以停车车辆坑位表示并发量来展开阐述的。 何为CountDownLatch CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，...
CountDownLatch源码浅析
my博客
09-26 115
文章目录CountDownLatch热身源码解析创建CountDownLatch对象countDown CountDownLatch也是juc包下的工具类，用于实现线程同步。 CountDownLacth 和juc（java.util.concurrent）包下的其他工具类一样，内部存在一个继承了AQS（AbstractQueuedSynchronizer）的内部类Sync。通过Sync来操作同步...
CountDownLatch源码解析之countDown()
08-27
CountDownLatch源码解析之countDown()方法详解 CountDownLatch是Java并发编程中的一种同步工具，用于控制线程的执行顺序。其中，countDown()方法是CountDownLatch的核心方法之一，负责减少计数器的值，并在计数器值...
源码详解CountDownLatch
12-21
CountDownLatch 是 Java 中一个强大的并发工具，用于协调多个线程之间的同步。它是 java.util.concurrent 包中的一个类，主要用于在多线程...理解 CountDownLatch 的工作原理有助于我们更有效地设计和优化多线程程序。
深探Java线程池协同神器——CountDownLatch的源码奥秘与实战应用
m0_51176516的博客
06-20 1643
CountDownLatch以其简洁高效的设计理念和强大的功能，成为Java多线程编程中的一大利器。通过对其源码的深入分析，不仅能更好地理解其工作原理，还能在实际应用中更加灵活、高效地使用它。在工程师的眼中，CountDownLatch不仅是一个线程同步工具，更是一个实现线程间高效协同的神器。
CountDownLatch
shibai906的博客
01-25 557
关于CountDownLatch，我从以下几方面进行讲解: 1、百度说明 同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。即，一组线程等待某一事件发生，事件没有发生前，所有线程将阻塞等待；而事件发生后，所有线程将开始执行；闭锁最初处于封闭状态，当事件发生后闭锁将被打开，一旦打开，闭锁将永远处于打开状态。 2、个人理解 执行一件事情，需要等几件事情全部执行完之后才能执行这件事情。比如：要想执行A功能，需要等B、C、D全部执行完之后，再去执行A功能。 3、代码示例 public
CountDownLatch源码简析
LO_YUN的博客
05-12 232
CountDownLatch把这个单词拆分成两部分，CountDown是倒计时的意思，Latch的意思是门闩，也就是锁的意思，所以CountDownLatch其实是一个倒计时锁，当倒计时不为0的时候，就会被锁阻塞，当倒计时为0时，锁会被释放，继续执行逻辑 先来一段demo代码 public class CountdownTest { public static void main(Stri...
CountDownLatch 源码浅析
等风
01-31 206
这里写自定义目录标题简介关键方法方法实现1. CountDownLatch(int count)构造器实现2. await()方法实现3. await(long timeout, TimeUnit unit)方法实现实现逻辑：4. countDown()方法实现 简介 CountDownLatch提供的是一个计数器倒数的功能。所有调用了await(long timeout, TimeUnit un...
CountDownLatch的源码学习
cheng的博客
11-09 150
一、简介 1、CountDownLatch类是一个同步辅助装置，允许一个或多个线程去等待直到另外的线程完成了一组操作。 2、它通过count进行初始化，await方法会阻塞直到当前的count为0由于调用了countDown方法，之后所有的线程将被释放并且立即返回结果。count不能被重置，如果你想count可以重置，请使用CyclicBarrier。 3、CountDownLatch是一个通用的同步工具，可用于多种用途。CountDownLatch初始化使用count作为一个简单的可开可关的大门：所有的线
CountDownLatch 源码解析
0xZzzz的博客
04-04 1391
CountDownLatch 源码详解
CountDownLatch源码解析。
孤芳不自赏
08-07 255
/** *一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 *用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。 *之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 ...
深入解析CountDownLatch源码：await()机制详解
"本文将深入解析CountDownLatch源码中的`await()`方法，它是Java并发工具类之一，用于线程间协调。`await()`方法使调用线程进入阻塞状态，直至计数器减为零或遇到中断。该方法的实现基于`AbstractQueuedSynchronizer...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值