CountDownLatch源码理解与使用介绍_countdowncit();-优快云博客

本文链接：https://blog.youkuaiyun.com/lhq1170159388/article/details/106891108

一、CountDownLatch介绍
CountDownLatch的作用在于，让一个或多个线程进入等待状态，直到其他一些线程执行完毕。
CountDownLatch的初始化需要传入一个count参数，await()方法会阻塞，直到count值因为countDown()方法的调用而变成0，之后，所有正在等待的线程将恢复，后续的await()方法的调用也会立即返回。这是一个一次性操作，count值不能被重置。当你需要能够重置count值的版本，你可以考虑CyclicBarrier。
每次调用countDown()方法，count的值都会减一。
总的来说，当某个线程调用await()方法，那么该线程就会等待，直到count的次数变为0，然后恢复运行；当某个线程调用countDown()方法时，count的值会减一。

二、原理介绍：为何能让当前线程等待
1、构造函数

public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    //初始化内部类
    this.sync = new Sync(count);
}

//private static final class Sync extends AbstractQueuedSynchronizer
Sync(int count) {
    setState(count);
}

//给父类AQS参数status赋值，status的值代表了锁的状态，status=0表示锁没有被任何线程获取；status为正数表示锁被线程持有，且锁是可重入的。
protected final void setState(int newState) {
    state = newState;
}

2、await()方法：如果status的值不为0，那么调用await方法所在的线程（主线程）会进入阻塞状态，直到status=0。（该方法有超时版）

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

//Sync子类
public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //判断能否获取到锁
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

//Sync子类
//当锁没有被线程持有，则返回1，对上一步方法来说，则直接返回（说明初始的count=0，或者，调用await方法的时候，已经调用了n次的countDown方法），不用等待；否则，说明锁被某个线程持有，需要进一步判断。
protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

//AQS类方法。走到这一步，说明status != 0，锁被某个线程持有
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    //用当前线程封装成Node对象（Node对象是AQS的内部类，用户构建CLH锁所用的链表）
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            //获取当前节点的前置节点（链表）
            final Node p = node.predecessor();
            if (p == head) {
                //走到这里，说明P是Head节点，那么去尝试一下获取锁（Head节点不属于CLH链表，说明当前节点排在链表的第一位，轮到它获取锁了）
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    //上面分析过，r>0，说明锁没有被线程持有，那么把Node节点设置为Head，并返回。（当前Node里的线程能获取到锁，就不能阻塞/挂起）
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            //关键方法：判断当前线程是否需要挂起/阻塞        挂起当前线程操作
            //那么main线程何时才能恢复执行呢？ 这就需要看countDown()方法了
            //在线程没被中断或者status != 0时，for循环会一直执行
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

//AQS方法，node节点入队列
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    //尾节点不为空，直接把当前节点置为尾节点
    if (pred != null) {
        node.prev = pred;
        //CAS操作
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //尾节点为空，或则CAS操作失败（说明其他线程也在进行入队列操作，在竞争中，CAS失败）
    enq(node);
    return node;
}

//AQS类。节点入队列
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        //尾节点为空，那么初始化Head节点。
        //第一次for循环，队列为空，执行队列初始化。第二次for循环，队列不为空，执行else的流程。
        if (t == null) {
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //队列已经初始化，采用CAS把当前节点设置为尾节点，for循环会保证设置成果（多个线程竞争设置尾节点），然后退出方法。
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

//判断线程获取锁失败后要不要挂起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    //CLH锁的节点会判断前一个节点的状态，当前一个节点的状态为Node.SIGNAL（值为-1）,说明后一个节点已经给前一个节点的waitStatus赋值，后续节点可以安全的挂起。
    //看到这里，我们没有看到当前node给前一个节点赋值的地方，那么ws就取默认值0
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        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赋值为-1，然后结束。由于调用方是for循环的方式，下次再执行本方法的时候，就会走到ws == Node.SIGNAL逻辑，返回true，表示需要当前线程需要挂起。
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

//AQS方法。调用LockSupport方法挂起线程。
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    //如果线程被中断了，这里返回true。回到上一层方法，会抛出InterruptedException，进而导致await方法结束。
    return Thread.interrupted();
}

3、countDown()：每调用一次，status的值就减1，当status=0时，导致await阻塞的for循环就结束了，main线程就可以继续往下走了。

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

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

//CountDownLatch类。
//status值减1，并用cas更新status的值
//本次减1导致status=0时，才返回true，此时上一步方法会执行释放锁操作。所以status的初始值是多少，就需要调用多少次countDown()方法。
protected boolean tryReleaseShared(int releases) {
    // Decrement count; signal when transition to zero
    for (;;) {
        int c = getState();
        if (c == 0)
            return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

//AQS
private void doReleaseShared() {
    /*
     * 
     */
    for (;;) {
        Node h = head;
        //到了这个位置，h != null && h != tail，tail为当前线程的节点
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                //恢复Head节点后续的线程
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

//AQS
private void unparkSuccessor(Node node) {
   
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;
    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;
    }
    //调用LockSupport恢复线程
    if (s != null)
        LockSupport.unpark(s.thread);
}

原理总结：新建CountDownLatch时，通过入参count，指定锁被获取了N次，调用await()方法时，主线程进入阻塞状态，直到调用countDown方法N次，导致status=0，使得锁没有被任何线程获取，触发主线程恢复为可被调度状态。

三、示例

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {

    private static final int THREAD_NUM = 5;

    private static CountDownLatch latch = new CountDownLatch(THREAD_NUM);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < THREAD_NUM; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "运行");
                latch.countDown();
            }, "线程" + i).start();
        }
        latch.await();
        System.out.println("主线程开始执行");
    }

}

运行结果：

线程0运行
线程4运行
线程1运行
线程2运行
线程3运行
主线程开始执行

结果分析：在线程0-4，调用完countDown()方法后，调用await()方法的主线程才开始执行。

四、参考
1、https://javadoop.com/post/AbstractQueuedSynchronizer