CountDownLatch的实现

最新推荐文章于 2025-06-21 17:09:17 发布

原创最新推荐文章于 2025-06-21 17:09:17 发布 · 1.5k 阅读

1 ·

CC 4.0 BY-SA版权

并发专栏收录该内容

13 篇文章

订阅专栏

本文深入探讨了CountDownLatch的实现机制，通过代码分析展示了其如何基于AQS实现等待和计数功能。CountDownLatch允许线程在特定条件满足后继续执行，当countDown方法被调用时，等待的线程按同步队列顺序获取资源。类比于公司与员工的关系，CountDownLatch在资源（计数）未耗尽时，线程等待，资源耗尽后，所有线程开始执行后续任务。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这是一个非常有意思的类，看下面的代码：

CountDownLatch countDownLatch = new CountDownLatch(1);
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				try {
					long startTime = System.currentTimeMillis();
					countDownLatch.await();
					long endTime = System.currentTimeMillis();
					System.out.println("awaitTime : " + (endTime - startTime) / 1000 + "seconds");
				} catch (InterruptedException e) {}
				
			}
		}).start();
		Thread.sleep(5000);
		countDownLatch.countDown();

我们创建的线程会在await那个地方等着，直到在其他地方调用了countDown这个方法，阻塞的方法才会继续执行，下面是我们代码执行的结果：
在这里插入图片描述
接下来我们就来看一下这个有趣的类是如何实现的：

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

我们发现这个类同样也是由AQS实现的：

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

将资源的数目设置为我们传进去的参数

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

await方法其实就是获取资源，在这个方法里面调用了在共享模式下可中断的获取资源：

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

首先尝试获取资源，如果返回值小于0就放到同步队列里面

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

如果剩余的资源的数目是0，说明不能获取资源了，要返回1，否则返回-1，既然是这样，那岂不是只有有资源的时候才有权利进入同步队列，这样想的话其实就和await的意思对应起来了，我们继续向下看来验证我们的猜想，由于资源的数目是1，所以肯定有剩余的资源：

private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

果真就和我们上一篇文章分析信号量一样的方法，这个类在获取资源的时候也是在共享模式下进行的，只不过信号量是在获取不到资源的时候才进入同步队列，而CountDownLatch是在有剩余资源的时候线程才进入同步队列，我们现在就清楚了，原来在有资源的情况下，线程调用await会直接进入同步队列，只有我们调用countdown的时候，它们才开始按同步队列的顺序来获取资源，接下来我们就看一下这个方法验证我们的猜想：

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

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

首先会尝试释放指定数目的资源，然后唤醒同步队列里面的结点：

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;
            }
        }

对同步对列中的资源数目-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;            // 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;
        }
    }

这个方法和信号量的方法是一样的我们就不在解释了，这个时候唤醒的线程在尝试获取资源的时候由于state是0，所以返回-1，成功从同步队列中移除。
到这里我们应该就清楚了，CountDownLatch的思路是这样的：
首先我们在创建这个类的时候会传入资源的个数，当我们调用await的时候，线程会因为还有剩余的资源而进入同步队列当中，只用当我们调用countdown方法的时候，会消耗资源，当资源消耗完毕的时候，所有线程才会有条不紊的从同步队列中出来继续工作。
那我们就可以举个例子了：CountDownLatch相当于一个公司，它手里有资金、这个公司还有前途的时候那些员工才会老老实实的跟着他，收起自己的小脾气，收起自己的理想，一旦这个公司将他的资金消耗光的时候，那些员工认为跟着呆在这个公司也没意思了，他都没钱了，更别说前途了，所以就会放弃他去干自己的事，去实现自己的理想。