【线程】CountDownLatch 内部原理（十三）

我的原则：先会用再说，内部慢慢来。
学以致用，根据场景学源码

---

一、概念

1. CountDownLatch 理解为：手动倒计时。（输入一个整数，然后每次-1，直到state = 0，退出）
   也叫做闭锁，在完成某些运算是，只有其他所有线程的运算全部完成，当前运算才继续执行。
   可以用于计算数量，平均值，等待线程退出等等等等。

=== 点击查看top目录 ===

二、主要方法

1. CountDownLatch#countDown 递减1
2. CountDownLatch#await() 共享锁阻塞等待 state = 0

=== 点击查看top目录 ===

三、源码分析

为了便于理解，建议先读一下我的另一篇文章，介绍AQS 【线程】ReentrantLock 源码剖析 （八）

=== 点击查看top目录 ===

3.1 整体架构

package java.util.concurrent;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class CountDownLatch {
	// 继承 AQS 的Sync
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) { //初始化设置状态，也就是锁的个数
            setState(count);
        }

        int getCount() { //获取锁数量
            return getState();
        }

        protected int tryAcquireShared(int acquires) { //尝试进行加锁 ，getState() == 0表示当前空闲，没人占据锁，我可以拿到
            return (getState() == 0) ? 1 : -1;
        }

        protected boolean tryReleaseShared(int releases) { //尝试释放锁，这个 releases参数没鸟用
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState(); //获取状态 
                if (c == 0) //是0的话，说明没有锁了，那么就释放失败，返回 false 
                    return false;
                int nextc = c-1;  //每次释放 1 
                if (compareAndSetState(c, nextc))  //CAS 设置状态，不成功就for自旋，必须设置成功为止
                    return nextc == 0;
            }
        }
    }

    private final Sync sync;

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

    public void await() throws InterruptedException { sync.acquireSharedInterruptibly(1); } //等待条件满足被唤醒

    public boolean await(long timeout, TimeUnit unit) //等待条件满足被唤醒 （条件加了个超市）
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    public void countDown() { sync.releaseShared(1); } // -1操作，拿掉一个锁

    public long getCount() {  return sync.getCount(); } // 获取锁数量

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

=== 点击查看top目录 ===

3.2 CountDownLatch 初始化

final CountDownLatch latch = new CountDownLatch(2);

• 看下构造方法 CountDownLatch(int count)

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

Sync(int count) {
    setState(count);
}

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    ...
	private volatile int state; // 当前持有锁的数量，0表示没人持有锁

    protected final void setState(int newState) {
        state = newState;
    }
    ...
}

初始化的目的就是：套N个锁上去，然后一个个拿掉。

=== 点击查看top目录 ===

3.3 await 剖析

java.util.concurrent.CountDownLatch#sync

• await 方法

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

• acquireSharedInterruptibly 方法

public final void AbstractQueuedSynchronizer#acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();  // 被打断就直接抛异常了
    if (tryAcquireShared(arg) < 0) // -1 没拿到锁，1 拿到了锁。
        doAcquireSharedInterruptibly(arg);  // -1没拿到锁才进入这个方法
}

• tryAcquireShared 方法

protected int Sync#tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;  // -1 没拿到锁，1 拿到了锁。
}

• doAcquireSharedInterruptibly 方法

下面的 addWaiter 方法建议看一下文章 【线程】ReentrantLock 源码剖析 （八）

// 跑到这个方法，说明没拿到锁
private void AbstractQueuedSynchronizer#doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED); //注意此处，加入的是 共享锁 ，addWaiter 方法，看一下之前的文章
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) { //唤醒，是唤醒 同步队列的第一个
                int r = tryAcquireShared(arg);
                if (r >= 0) { // -1 没拿到锁，1 拿到了锁。
                    setHeadAndPropagate(node, r); // 这个是重点！！！这个会唤醒下一个持有共享锁的线程
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt()) // 全部阻塞在这里，被唤醒一个个醒过来,第一个NodeNew后的thread最先醒过来，
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

• setHeadAndPropagate 方法

private void AbstractQueuedSynchronizer#setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    setHead(node);
    
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared(); // 这里是重点啊！！！共享锁直接进来这个方法
    }
}

---

final boolean AbstractQueuedSynchronizer.Node#isShared() {
    return nextWaiter == SHARED;
}

private void AbstractQueuedSynchronizer#setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

• 看下 doReleaseShared 方法

private void AbstractQueuedSynchronizer#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;            // 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;
    }
}

注意：await 方法被notify之后，会去 notify 下一个持有共享锁share lock 的thread，具体看 方法setHeadAndPropagate

doReleaseShared 方法调用场景

1. countDown 的时候调用
2. thread被notify之后，调用setHeadAndPropagate之后再调用

=== 点击查看top目录 ===

3.4 countDown 剖析

• countDown 方法

public void CountDownLatch#countDown() {
    sync.releaseShared(1);  // 释放共享锁
}

• releaseShared 方法

public final boolean AbstractQueuedSynchronizer#releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
    	// 能进来这里，说明 getState() 已经等于 0 了，也就是没有线程持有锁了，这是 countDown 的最后一次。
        doReleaseShared(); //释放操作
        return true;
    }
    return false;
}

• tryReleaseShared 方法

protected boolean Sync#tryReleaseShared(int releases) {
    // Decrement count; signal when transition to zero
    for (;;) { // 自旋CAS
        int c = getState();
        if (c == 0)
            return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
            return nextc == 0; //等于0的话，返回true，就要叫醒同步队列的线程了
    }
}

====== doReleaseShared方法 ====== 查看

=== 点击查看top目录 ===

---

看源码一般都能看懂，看不懂就往下走看下调试剖析。

四、场景分析

1. 多thread await阻塞，等待被唤醒
2. CountDown到0，开始唤醒

1. 多thread await阻塞，等待被唤醒

结构如下：

代码：

public class _05_02_TestCountDownLatch {
    public static void main(String[] args) throws Exception {
        System.out.println(Thread.currentThread().getName());
        final CountDownLatch latch = new CountDownLatch(2);

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                Scanner sc = new Scanner(System.in);
                System.out.println("点击任意键终止线程 ...");
                sc.nextLine();
                latch.countDown();
            }, "A_" + i).start();
        }

        // sleep 保证上面先执行
        Thread.sleep(1000);

        // 多个线程await等待，模拟排队
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    latch.await();
                    System.out.println(Thread.currentThread().getName() + " be notified .");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"C_" + i).start();
        }

        // sleep 保证上面先执行
        Thread.sleep(1000);
        System.out.println("Main latch.await()... ");
        // 这个地方 latch.await()； 目的是为了查看排队状态
        latch.await();
        System.out.println("main end");
    }
}

输出：

main
点击任意键终止线程 ...
点击任意键终止线程 ...


C_0 be notified .
C_4 be notified .
C_3 be notified .
C_2 be notified .
C_1 be notified .
Main latch.await()... 
main end

断点位置：(现在就先打一个地方，然后逐渐 Step Into 进去）

expression：Thread.currentThread().getName().equals(“main”)

断点停下来的位置，位于 main 方法的 latch.await() 位置的下一步，如下图：

• 开始看调试分析：
  

1. state = 2 说明有线程持有锁
2. nextWaiter的作用仅仅为了判断 s.isShared() . 使用的地方： 方法setHeadAndPropagate
3. 说明head节点只是个NodeNew， 具体看doAcquireSharedInterruptibly#addWaiter(Node.SHARED)
4. exclusiveOwnerThread = null，说明没有独占锁，那么前面那个2是共享锁。我们在代码 doAcquireSharedInterruptibly#addWaiter(Node.SHARED) 也可以知道加的是Shared锁。
5. 一排next，说明都在阻塞排队

=== 看下结构图 ===

=== 点击查看top目录 ===

2. CountDown到 0，开始唤醒

• Countdownlatch 唤醒的代码，我就不贴了。下面看第一个thread被唤醒后，是怎么把同步链表的Node逐个唤醒的。

1. 唤醒第一个之后，进入 方法setHeadAndPropagate ，setHead(node); 方法让head 右移。
   

2. 看下图，第一次唤醒的肯定是第一个节点 head的下一个

3. CountDownlatch 到最后，肯定释放了全部锁，那么 tryAcquireShared() = 1，进入 setHeadAndPropagate 方法

3. setHeadAndPropagate 方法 doReleaseShared() 释放下一个节点。

=== 点击查看top目录 ===

五、番外篇

下一章节：【线程】ThreadLocal 剖析 （十四）
上一章节：【线程】线程八锁与Synchronzied内部原理（十二）