CountDownLatch源码解析

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

1、Java中的CountDownLatch是什么？

位于java.util.cucurrent包下的一个对象，能够达到线程等待的效果，例：

主线程中调用子线程，需要拿到子线程中调用的方法结果，也就是主线程需要等待子线程执行完再做返回

代码示例：

public class CountDownLatchTest {

    public static void main(String[] args) throws Exception {

        List<Integer> list = Collections.synchronizedList(new ArrayList<>());

        new Thread(()->{
            System.out.println("子线程执行");
            Integer result = getData();
            list.add(result);
        }).start();

        System.out.println("子线程处理结果："+list);
        System.out.println("主线程结束");
    }

    private static Integer getData(){
        return 1;
    }

}

在这里插入图片描述
发现不仅子线程执行的输出语句在主线程之后，并且list集合为空，也就是说主线程并没有等待子线程执行完就结束了，而CountDownLatch的作用就是让主线程等待子线程执行完再执行。

代码修改后：

public class CountDownLatchTest {

    public static void main(String[] args) throws Exception {

        CountDownLatch countDownLatch = new CountDownLatch(1);

        List<Integer> list = Collections.synchronizedList(new ArrayList<>());

        new Thread(()->{
            System.out.println("子线程执行");
            Integer result = getData();
            list.add(result);
            countDownLatch.countDown();
        }).start();

        countDownLatch.await();

        System.out.println("子线程处理结果："+list);
        System.out.println("主线程结束");
    }

    private static Integer getData(){
        return 1;
    }

}

在这里插入图片描述
达到我们预期的结果，主线程在子线程执行完后才做执行输出。

简而言之：

CountDownLatch能够使一个线程在等待其他线程完成各自工作之后，再继续执行

2、从源码我们去分析CountDownLatch的原理

#重点关注CountDownLatch中这俩个方法源码和作用
//当每有一条线程执行完毕后就做减一操作
countDownLatch.countDown();
//判断new CountDownLatch(int count) 中的count是否为0，为0则标记着子线程全部执行完毕，否则阻塞主线程，直到count == 0
countDownLatch.await();

我们在new CountDownLatch 的时候，都需要传入一个int类型数值
CountDownLatch countDownLatch = new CountDownLatch(1);

#从构造方法进来
public CountDownLatch(int count) {
		#count不能小于0，否则抛异常
        if (count < 0) throw new IllegalArgumentException("count < 0");
        #赋值Sync对象
        this.sync = new Sync(count);
    }

查看CountDownLatch中的Sync对象

#发现Sync对象继承了AQS,不明白AQS的建议先去看下AQS的源码 
private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
		
		#在CountDownLatch的构造方法中调用的是Sync的构造方法
		#
        Sync(int count) {
        	#调用父类AQS的setState方法将AQS中的state变量设置为传入的count值
            setState(count);
        }
    }

总结：CountDownLatch的构造方法中，调用父类AQS的setState方法,将AQS中的state变量设置为我们传入的计数值。

countDown()方法

public void countDown() {
		#固定传入1，进入releaseShared(1)方法
        sync.releaseShared(1);
    }

    public final boolean releaseShared(int arg) {
    	#调用AQS的tryReleaseShared(arg)方法
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

找到CountDownLatch对AQS重写的tryReleaseShared方法的实现：

#CountDownLatch中对于AQS方法的实现
protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            #递减计数，过度到0时信号
            for (;;) {
            	#拿到AQS中刚才new时设置的state值
                int c = getState();
                #如果state == 0 表明子线程已经执行完 state递减至0 返回false 结束方法
                if (c == 0)
                    return false;
                #state != 0 ,对state执行减一操作    
                int nextc = c-1;
                #利用AQS中的compareAndSetState方法更新state值
                if (compareAndSetState(c, nextc))
                	#校验state值是否为0 为0 返回false
                    return nextc == 0;
            }
        }

通过上面分析：countDown方法主要就是对开始设置state值进行减一操作，每当一条子线程执行完毕 就对state减一

继续回到releaseShared(int arg)方法

    public final boolean releaseShared(int arg) {
    	#调用AQS的tryReleaseShared(arg)方法
    	#分析完tryReleaseShared(arg)方法，我们知道通过返回的boolean值来确定是否执行doReleaseShared()方法
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

当发现state == 0，返回false时，意味着子线程全部执行完毕，进入到doReleaseShared()方法：

    private void doReleaseShared() {
        for (;;) {
        	#获取AQS中队列的头节点
            Node h = head;
            #头节点不等于null 且 头节点不等于尾节点时
            if (h != null && h != tail) {
            	#获取头节点中线程的状态
                int ws = h.waitStatus;
                #检验节点状态是否为取消停放状态（意味着节点从排队等待变成换醒执行）
                if (ws == Node.SIGNAL) {
                	#通过CAS设置节点状态，成功则执行unparkSuccessor(h)方法，失败则结束方法 重新进入循环
                    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;
        }
    }

unparkSuccessor(h)方法：

private void unparkSuccessor(Node node) {
        
        int ws = node.waitStatus;
        #通过上面设置此时节点状态已经 == 0
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        #拿到node的下一节点
        Node s = node.next;
        #下一节点 == null 或者 状态 为取消
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        #当next节点不为 null 时，代表着next节点需要进行释放 线程执行
        if (s != null)
        	#调用LockSupport的unpark方法对封装的节点进行释放
            LockSupport.unpark(s.thread);
    }

分析unparkSuccessor()方法得知，在每一条子线程执行完都会调用countDown方法，执行减一操作，并且校验AQS中的state是否为0，如果为0，则说明子线程全部执行完毕，需要去释放AQS同步队列中头部节点的next节点，而next节点里面实际封装的就是主线程，只不过是主线程调用await方法，检测到state不为0，子线程还未执行完，所以将主线程放入同步队列等待唤醒。

await()方法

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

调用AQS的acquireSharedInterruptibly方法：

    public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

对AQS的tryAcquireShared方法重写

        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

此段代码主要就是在 校验tryAcquireShared(arg) < 0方法的返回结果是否小于0，通过CountDownLatch对此方法的重写得知，如果state为0，说明子线程执行完毕，主线程则不需要执行doAcquireSharedInterruptibly(arg)方法，结束await方法，反之state != 0，则说明子线程未执行完，需要执行doAcquireSharedInterruptibly(arg)方法，将其阻塞放入同步队列，等待子线程执行完毕唤醒。

所以我们重点分析doAcquireSharedInterruptibly(arg)方法：

    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        #加入队列
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
            	#获取node节点的上一节点
                final Node p = node.predecessor();
                #上一节点为头节点
                if (p == head) {
                	#校验state是否为0
                    int r = tryAcquireShared(arg);
                    #state为0
                    if (r >= 0) {
                    	#设置当前节点为头节点
                        setHeadAndPropagate(node, r);
                        #设为null gc回收 说明此时子线程已经执行完，不在需要将主节点放入队列对其阻塞
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                #阻塞主线程
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

在doAcquireSharedInterruptibly(int arg)中主要做了俩件事：
1、将当前线程（主线程）加入同步队列队列
2、设置线程状态，对其阻塞，等待唤醒

下面分析这一步代码：final Node node = addWaiter(Node.SHARED);

    private Node addWaiter(Node mode) {
    	#将当前线程（主线程）封装成node节点
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        #获取尾节点
        Node pred = tail;
        #尾节点不为null的情况下，说明同步队列已存在，不需要再创建
        if (pred != null) {
        	#设置node（主线程）节点的前指向为pred节点
            node.prev = pred;
            #利用cas将node节点设置为尾节点
            if (compareAndSetTail(pred, node)) {
            	#设置成功后，将原来尾节点的后指向设置为node（主线程）节点
            	#				--->
            	#pred(原来尾节点)      node(主线程封装成的当前节点，经过操作，node节点已经成为队列新的尾节点)
            	#               <---
                pred.next = node;
                return node;
            }
        }
        #尾节点为null 说明当前AQS的同步队列为null 需要创建，继续分析enq(node)方法
        enq(node);
        return node;
    }

addWaiter(Node mode)方法中第一步先去看AQS中同步队列是否存在，存在将当前线程设置为队列中新的尾部节点
不存在则继续走enq(node)方法，我们继续往下分析：

    private Node enq(final Node node) {
        for (;;) {
        	#获取尾节点
            Node t = tail;
            #尾节点为null则去初始化队列
            if (t == null) { // Must initialize
            	#当同步队列第一次设置时，会new一个空节点在做头节点
                if (compareAndSetHead(new Node()))
                	#再将空的节点设置成尾节点
                    tail = head;
            } else {
            	#不为null 就将node节点设置成队列中新的尾节点
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

至此将当前主线程放入队列就分析完，接下来就会对其阻塞，等待子线程调用countDown方法唤醒

分析doAcquireSharedInterruptibly(int arg)方法中阻塞主线程的操作，阻塞前会先去设置线程的状态

  1. shouldParkAfterFailedAcquire(p, node) 设置线程节点状态
  2. parkAndCheckInterrupt() 对其阻塞
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    	#此时node节点上一节点状态为0
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
             #自旋设置成-1时，放回true 结束自旋
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
             #为0时 设置其为-1，代表next节点等待释放
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

    private final boolean parkAndCheckInterrupt() {
    	#调用LockSupport方法中的park方法对主线程阻塞
        LockSupport.park(this);
        return Thread.interrupted();
    }

经过对CountDownLatch中俩个重要的方法countDown和await方法分析，我们已经对其如何让线程等待，如何重写AQS方法实现多线程共享变量达到安全的目的。接下来用一张线程执行图来更好的表现出其执行逻辑。

在这里插入图片描述

如有错误，欢迎指正。

"小王"
关注
专栏目录
【搞定Java并发编程】第24篇：Java中的并发工具类之CountDownLatch
Java学习
12-18 472
上一篇：Java中的阻塞队列 BlockingQueue 详解 本文目录： 1、CountDownLatch的基本概述 2、CountDownLatch的使用案例 3、CountDownLatch的源码分析 1、CountDownLatch的基本概述 CountDownLatch允许一个或多个线程等待其他线程完成操作。 CountDownLatch又称为“闭锁”，它是一个同步辅助...
《Java源码分析》：CountDownLatch
wojiushimogui的博客
08-04 1552
《Java源码分析》：CountDownLatchLatch：闭锁。有人把Latch比喻成是一个门，在门打开之前，所有想进门的线程都被阻塞，在门打开之后，所有想进门的线程全部通过，且门打开之后就不能再关闭。CountDownLatch是一个同步辅助类，允许一个或多个线程等待直到其它线程的一些操作已经准备完成。CountDownLatch是JDK 5+里面闭锁的一个实现，允许一个或者多个线程等待某个事
CountDownLatch源码分析
meser88的博客
05-22 350
CountDownLatch(闭锁)是一个同步协助类，允许一个线程或多个线程阻塞等待，直到其他线程完成操作后，被阻塞的线程才会被唤醒，然后执行后面的业务逻辑。CountDownLatch基于共享模式实现，的构造方法需要给定一个计数值(count)进行初始化。
CountDownLatch源码解析之await()
08-27
CountDownLatch源码解析之await() CountDownLatch是Java并发编程中常用的同步工具，通过await()方法可以让当前线程处于阻塞状态，直到锁存器计数为零（或者线程中断）。下面我们将详细解析CountDownLatch源码之...
CountDownLatch源码解析之countDown()
08-27
CountDownLatch源码解析之countDown()方法详解 CountDownLatch是Java并发编程中的一种同步工具，用于控制线程的执行顺序。其中，countDown()方法是CountDownLatch的核心方法之一，负责减少计数器的值，并在计数器值...
5、CountDownLatch源码分析
夏季版
09-25 484
首先看下下面这段代码： package com.mmall.concurrency.example.atomic; import com.mmall.concurrency.annoations.ThreadSafe; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.CountDownLatch; import jav...
深入解析CountDownLatch核心源码
Dream_it_possible！的博客
06-10 805
一、CountDownLatch 介绍 CountDownLatch是JUC包下的并发关键字，可以通过CountDownLatch可以等待多个子线程
CountDownLatch源码解读
李哈zzz的博客
02-21 1095
前言 目前也是金三银四跳槽找工作的最好时机，可能很多小伙伴在面试中被面试官问到Java并发包方面的问题。比如你对Java并发包的了解有多少？有了解是吧，那你在项目中使用过CountDownLatch吗？使用的场景有哪些？对它的原理知道多少？等等一系列问题。所以特意写一篇关于CountDownLatch的源码解读，帮助大家顺利通过面试。 正文 CountDownLatch使用场景 比如说，在多线程情况下，其中一个或多个线程需要等待其他线程执行完毕才能执行。 比如执行A业务需要先查B业务和C..
Java源码分析之CountDownLatch
weixin_34380296的博客
12-10 135
一、CountDownLatch介绍 CountDownLatch是一种同步手段，允许一个或者更多的线程等待，直到在其他线程正在执行的一组操作完成。给定count数目后CountDownLatch被初始化。await()方法阻塞，直到由于调用countDown()方法，当前count值达到0，之后所有等待线程被释放，而任何后...
实战java高并发程序设计之CountDownLatch源码分析
星空下的程序猿
10-11 568
上篇文章讲到线程和进程的概念，并结合源码理解线程的各种状态，包括创建过程init()，启动过程start()，运行run()，退出exist()，等待和阻塞等。这篇博文主要讲JUC包中常用的并发工具类：CountDownLatch，CyclicBarrier，ReadWriteLock，Semaphore。 首先看第一个！ CountDownLatch 使用场景 CountDownLatch类是常...
CountDownLatch源码解析。
孤芳不自赏
08-07 269
/** *一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 *用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。 *之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 ...
CountDownLatch 源码
最新发布
纸上得来终觉浅，绝知此事要躬行
07-03 348
state是一个volatile类型的变量，保证了对它的读写操作的可见性，以及禁止了指令重排序，从而确保了线程之间对state的操作是正确的和可靠的。
CountDownLatch源码
我的博客
06-22 681
CountDownLatch是依赖AQS完成的线程阻塞和唤醒，利用AQS的共享锁完成锁的多线程获取和释放。 CountDownLatch 使用了共享锁模式。CountDownLatch 使用一个内部类 Sync来实现CountDownLatch的同步控制，而Sync是AQS的一个实现类，它使用AQS的状态（state）来表示count。 用给定的计数初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await() 方法会一直受阻塞。之后，会释放所有
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值