CountDownLatch源码解读

目录

前言

正文

CountDownLatch使用场景

CountDownLatch简单的使用

CountDownLatch源码解读

CountDownLatch结构和构造方法

await()方法

countDown()方法

总结

---

前言

目前也是金三银四跳槽找工作的最好时机，可能很多小伙伴在面试中被面试官问到Java并发包方面的问题。比如你对Java并发包的了解有多少？有了解是吧，那你在项目中使用过CountDownLatch吗？使用的场景有哪些？对它的原理知道多少？等等一系列问题。所以特意写一篇关于CountDownLatch的源码解读，帮助大家顺利通过面试。

正文

CountDownLatch使用场景

比如说，在多线程情况下，其中一个或多个线程需要等待其他线程执行完毕才能执行。

比如执行A业务需要先查B业务和C业务，获取到B和C的返回值才能执行A业务，就可以使用到CountDownLatch，虽然也可以使用到传统的join关键字来实现。

CountDownLatch简单的使用

/**
 * @Author liha
 * @Date 2022-02-20 20:49
 * 李哈YYDS
 */
public class CountDownLatchTest {
    
    public static void main(String[] args) {

        final CountDownLatch countDownLatch = new CountDownLatch(2);

        new Thread(()->{
            System.out.println("此线程模拟A业务");
            try {

                // 开始等待B和C业务执行完毕
                countDownLatch.await();

                // A业务开始执行
                TimeUnit.SECONDS.sleep(1);
                System.out.println("A业务执行完毕");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            System.out.println("此线程模拟B业务");

            try {
                // 模拟B业务的执行时间
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B业务执行完毕");
            countDownLatch.countDown();
        }).start();

        new Thread(()->{
            System.out.println("此线程模拟C业务");

            try {
                // 模拟C业务的执行时间
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("C业务执行完毕");
            countDownLatch.countDown();
        }).start();
        
    }
}

 如果传统的单线程情况下先查B再查C，要花费4秒，使用到多线程+CountDownLatch只需要花费3秒，如果业务更多的话效率会更高，并且建议一定要有一个全局的线程池来管理线程。

CountDownLatch源码解读

CountDownLatch结构和构造方法

先查看到CountDownLatch的一个内部结构

 可以看到也是内部维护了一个Sync对象，Sync对象继承AQS。 所以也是一个传统基于AQS框架的一个技术。并且与ReentrantLock那些技术相比内部方法比较少，比较简答。

// 内部构造方法，new一个Sync传一个计数器值进去。
public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}


// 给AQS内部维护的state传值。
Sync(int count) {
    setState(count);
}

对于AQS做一个解释吧，考虑可能有新手

AQS算是Java并发包下的一个框架，很多并发技术都是基于AQS来实现。

AQS内部维护了一个state，一个队列，一个当前线程的引用。

state：因为有些情况是可重入锁所以使用控制state来判断是否还有线程占用锁，内部使用volition和CAS来保证state的原子性。

队列：存放获取锁失败或阻塞的线程。内部是一个双向链表，往往head节点是一个sentinel节点，算是一个标识节点，作用是用来唤醒sentinel的next节点的线程。

await方法：线程休眠，当state为0被唤醒

countDown方法：计数器－1，也就是state减1，当state为0时，执行唤醒被休眠的线程。

await()方法

先看到await()方法。

 构造方法将计数器的值赋值给state，所以这里肯定是-1，进入到doAcquireSharedInterruptibly()方法中

// 首先我们先要明白await()方法多个线程都能使用，目的是休眠线程，等待计数器为0
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {

    // Node.SHARED 代表共享节点，共享节点就代表当线程被唤醒时会唤醒下一个等待的共享节点。
    // 将当前线程节点加入到AQS内部维护的队列中，如果内部队列还未初始化就执行初始化操作
    // 具体的添加节点或者初始化操作方法看最下面的代码
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {

        // 开始自旋
        for (;;) {

            // 获取到当前线程节点的prev节点，也就是当前节点的上一个节点
            final Node p = node.predecessor();

            // 如果上一个节点是sentinel节点，因为head是指向于sentinel节点的，就达标可以尝试获取锁
            if (p == head) {

                // 尝试获取到锁，前面截图过这个方法的实现，也就是判断state的值是不是0。
                int r = tryAcquireShared(arg);

                // state如果不为0就为-1，所以进不了这边，如果为0了就是计数器已经都释放了。
                if (r >= 0) {
        
                    // 将head指向于当前线程节点，并且获取到当前线程节点的next节点，也就是下一个节点
                    // 如果下一个节点是shared节点就唤醒。
                    setHeadAndPropagate(node, r);

                    // 将上一个节点的next指向于null，此时head也不指向于他，所以已经被丢弃出去。
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }

            // shouldParkAfterFailedAcquire()将上一个节点的状态位改成-1
            // parkAndCheckInterrupt()将当前线程park休眠让出cpu的占用。
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}



private Node addWaiter(Node mode) {
    // 创建出当前节点，并且当前节点是共享节点
    Node node = new Node(Thread.currentThread(), mode);

    // tail是aqs外部队列指向队列最后一位的全局变量，未初始化的情况下肯定为null，已经初始化的话就获取到最后一位。
    Node pred = tail;
    if (pred != null) {

        // 因为队列是一个双向链表，所以prev就把当前节点的上一个节点指向最后一个节点，也就是插入到最后一位
        node.prev = pred;

        // 把aqs尾部的tail全局变量指向到当前节点，也就是代表当前节点是最后一位。
        if (compareAndSetTail(pred, node)) {

            // 此时的pred是之前的最后一位的引用，所以把当前节点的前一位的next节点指向到当前节点
            pred.next = node;
            return node;
        }
    }

    // 初始化操作。
    // 不追进去了，这里大概讲解一下。
    // 创建一个sentinel节点，将sentinel节点的waitState状态改为-1，并且将AQS维护的head全局变量
    // 指向sentinel节点，并且将sentinel节点的next指向到当前节点，当前节点的prev指向到sentinel节点
    // 其实也就是一个很普通的双向链表操作。
    enq(node);
    return node;
}

doAcquireSharedInterruptibly()方法中，将当前线程进入到park之前还是尝试了几次获取到锁，如果几次尝试并没有成功，计数器并没有减到0，就会进入到休眠状态，让出对cpu占用。

目前内部的队列的结构如下

countDown()方法

再看到计数器减一的方法

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


public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

先看到if判断中的tryReleaseShared()方法。

protected boolean tryReleaseShared(int releases) {
    // Decrement count; signal when transition to zero
    for (;;) {
    
        // 获取到AQS内部维护的state状态位，state状态位是CountDownLatch构造方法传进去的。
        int c = getState();

        // 注意这里是cas+死循环，所以是多线程来改变state状态位，所以可能抢不到的线程要自旋来该状态
        // 并且当状态位为0的时候就代表CountDownLatch的计数器已经为0了，就达标其他线程通过下面的
        // cas操作将state改成为0执行其他语句去了。  所以没抢到线程这里就已经没事可干了。
        if (c == 0)
            return false;

        // 状态位预减1,注意这里是预减，因为多线程的情况下还要cas来保证原子性。
        int nextc = c-1;
        
        //cas操作，c是预期值，nextc是改变值，如果在并发的情况下为false的就继续自旋，为true的就判断是否状态为0，为0就要执行唤醒等待线程
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

当state状态位为0的时候就执行到doReleaseShared()方法。

    // 能进来
    private void doReleaseShared() {
        // 自旋
        for (;;) {

            // 获取到head的指向节点,head也有可能为null，因为并没有线程在await
            Node h = head;

            // 判断是否有线程在await
            if (h != null && h != tail) {

                // 能进来的话，就代表head和tail有指向，并且head指向的sentinel节点
                int ws = h.waitStatus;

                // 在park之前将sentinel节点的waitStatus改为SIGNAL了
                if (ws == Node.SIGNAL) {

                    // 这里考虑为什么要cas？
                    // 因为来await中的操作，显示初始化head节点，和sentinel节点之类的
                    // 初始化后才通过cas将sentinel节点的waitState改成SIGNAL
                    // 如果失败就自旋重试。
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    
                    // 这里是上面的cas操作成功了，就唤醒head指向的节点的next节点。
                    unparkSuccessor(h);
                }

                // PROPAGATE这个标志的修改我翻阅了帖子说是解决bug，但是全局就这里出现了。
                // 后面等我了解了bug以后会写篇帖子来讲解。
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }

            // 这里是多线程情况下预防await()方法对head和tail和队列初始化了。
            if (h == head)                   // loop if head changed
                break;
        }
    }

这里唤醒以后会进入到唤醒线程的park()方法处。

 被唤醒后就查看是否需要继续唤醒当前节点的next节点。并且对链表和head和tail做一些处理。入地就是让当前节点的prev节点也就是sentinel节点指向为null，被gc回收。

被唤醒后就可以正常执行当前线程的业务逻辑了。

总结

总体来说还是比较简单，建议大家debug来调试追一下，结合博主的帖子中代码中的注释来理解。

最后如果本帖对大家有帮助，希望大家点赞+关注！后续一直会出各种源码的解读！