相关文章：
CountDownLatch，即倒计时器，是一个同步工具类，用于协调多个线程之间的同步，常用来控制线程等待，它可以让某个线程一直处于等待状态直到倒计时结束后再开始执行
一、内部类解析
-
Sync
private static final class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = 4982264981922014374L; // Sync 构造方法，初始化计数 Sync(int count) { setState(count); } // 获取当前计数 int getCount() { return getState(); } // 获取当前计数，如果为 0，则返回 1；如果不为 0，则返回 -1 protected int tryAcquireShared(int acquires) { return (getState() == 0) ? 1 : -1; } /* * 减小当前计数，如果当前计数为 0，则返回 false； * 如果减小后的计数为 0，则返回 true，如果不为 0，则返回 false */ protected boolean tryReleaseShared(int releases) { // Decrement count; signal when transition to zero for (;;) { // 获取当前计数 int c = getState(); // 如果当前计数为 0，则返回 false if (c == 0) return false; // 如果当前计数不为 0，则减 1 int nextc = c-1; // 使用 CAS 操作将当前计数由 c 更新为 nextc if (compareAndSetState(c, nextc)) /* * 判断当前计数减 1 后是否等于 0 * 如果为 0，则返回 true；如果不为 0，则返回 false */ return nextc == 0; } } }- Sync 是 CountDownLatch 的内部类，用于帮助 CountDownLatch 进行同步控制，其继承自 AQS，并使用 AQS 的同步状态 (state) 来表示当前计数
二、字段解析
-
sync
private final Sync sync;- sync 是内部类 Sync 的一个实例
三、构造方法解析
-
CountDownLatch(int count)
public CountDownLatch(int count) { // 如果初始计数小于 0，则抛出异常 if (count < 0) throw new IllegalArgumentException("count < 0"); // 实例化 sync 对象 this.sync = new Sync(count); }- CountDownLatch 仅有这个构造方法，使用给初始数完成 Sync 对象的初始化，并使用该计数设置 Sync 的同步状态 (state)
四、方法解析
1、await() 相关方法
-
await()
public void await() throws InterruptedException { sync.acquireSharedInterruptibly(1); }- 阻塞当前线程，直到锁存器倒计数为 0 或线程被中断为止
-
acquireSharedInterruptibly(int arg)
public final void acquireSharedInterruptibly(int arg) throws InterruptedException { // 如果线程被中断，则抛出异常 if (Thread.interrupted()) throw new InterruptedException(); // 尝试获取共享锁 if (tryAcquireShared(arg) < 0) // 在可中断模式下获取共享锁 doAcquireSharedInterruptibly(arg); }- 获取共享锁，如果中断则中止
-
tryAcquireShared(int arg)
protected int tryAcquireShared(int arg) { throw new UnsupportedOperationException(); }- 尝试获取共享锁，该方法没有具体实现，交由子类实现，此处实际调用的是 CountDownLatch 内部类 Sync 中的
tryAcquireShared(int acquires)方法 (获取当前计数，如果为 0，则返回 1；如果不为 0，则返回 -1)
- 尝试获取共享锁，该方法没有具体实现，交由子类实现，此处实际调用的是 CountDownLatch 内部类 Sync 中的
-
doAcquireSharedInterruptibly(int arg)
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException { // 创建一个共享节点 node，将其加入到 CLH 队列尾部 final Node node = addWaiter(Node.SHARED); // 标记是否成功获取资源 boolean failed = true; try { for (;;) { // 获取 node 节点的前驱节点 p final Node p = node.predecessor(); /* * 如果 p 节点为头部节点，则 node 节点会尝试 * 获取共享锁，如果获取成功，则进行后续流程 */ if (p == head) { /* * 此处调用了 CountDownLatch 内部类 * Sync 中的 tryAcquireShared(int acquires) 方法 * (获取当前计数，如果为 0，则返回 1；如果不为 0，则返回 -1) */ int r = tryAcquireShared(arg); // 如果当前计数为 0 (r 为 1) if (r >= 0) { // 将 node 节点设置为头部节点，并唤醒后继节点 setHeadAndPropagate(node, r); /* * 此时 CLH 队列的头部节点为 node 节点， * 原先的头部节点 p 已处理完资源出队， * 因此将 p 节点的 next 引用设置为 null * 方便 GC 对 P 节点进行回收 */ p.next = null; // help GC failed = false; return; } } /* * 如果 p 节点不为头部节点，则根据 p 节点 * 的状态来判断是否要阻塞 node 节点 */ if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) throw new InterruptedException(); } } finally { // 如果未成功获取资源，则取消 node 节点获取锁的尝试 if (failed) cancelAcquire(node); } }- 在可中断模式下获取共享锁
-
addWaiter(Node mode)
private Node addWaiter(Node mode) { /* * 根据当前线程和给定模式，创建一个 Node 节点 * model: SHARED(共享)、EXCLUSIVE(独占) */ Node node = new Node(Thread.currentThread(), mode); // 将 pred 节点的引用指向尾部节点 Node pred = tail; // 如果 pred 节点不为 null if (pred != null) { // 则将 pred 节点设置为 node 节点的前驱节点 node.prev = pred; // 使用 CAS 操作将尾部节点由 pred 节点更新为 node 节点 if (compareAndSetTail(pred, node)) { // 将 node 节点设置为 pred 节点的后继节点 pred.next = node; return node; } } /* * 如果 pred 节点为 null，或上述 * compareAndSetTail(pred, node) 操作失败， * 则调用 enq(final Node node) 方法将 node * 节点加入到 CLH 队列尾部 */ enq(node); return node; }- 根据当前线程和给定模式，创建一个 Node 节点，将其加入到 CLH 队列尾部
-
enq(final Node node)
private Node enq(final Node node) { for (;;) { // 将 t 节点的引用指向尾部节点 Node t = tail; // 如果 t 节点为 null if (t == null) { /* * 说明队列为空，则创建一个新的 Node * 节点作为队列的头部节点和尾部节点 */ if (compareAndSetHead(new Node())) tail = head; // 如果 t 节点不为 null } else { // 说明队列不为空，则将 t 节点设置为当前节点的前驱节点 node.prev = t; // 使用 CAS 操作将尾部节点由 t 节点更新为当前节点 if (compareAndSetTail(t, node)) { // 将当前节点设置为 t 节点的后继节点 t.next = node; return t; } } } }- 将当前节点加入到 CLH 队列尾部
-
setHeadAndPropagate(Node node, int propagate)
private void setHeadAndPropagate(Node node, int propagate) { // 将 h 节点的引用指向旧的头部节点 Node h = head; // 将当前节点设置为新的头部节点 setHead(node); /* * 此处 propagate 为 CountDownLatch 内部类 Sync 中的 * tryAcquireShared(int acquires) 方法的返回值，即当前计数，是决定是否传播的依据之一 * * 如果当前计数大于 0，或旧头部节点为 null， * 或旧头部节点状态不为 CANCELLED(1) 或默认状态 (0)， * 或新头部节点为 null，或新头部节点状态不为 CANCELLED(1) 或默认状态 (0) */ if (propagate > 0 || h == null || h.waitStatus < 0 || (h = head) == null || h.waitStatus < 0) { // 将 s 节点的引用指向当前节点的后继节点 Node s = node.next; /* * 如果 s 节点为 null 或 s 节点为 * 共享节点，则对后继节点进行唤醒传播 */ if (s == null || s.isShared()) doReleaseShared(); } }- 设置当前节点为头部节点，并根据
tryAcquireShared(int acquires)方法的返回值以及节点状态来判断是否需要唤醒后继节点
- 设置当前节点为头部节点，并根据
-
doReleaseShared()
private void doReleaseShared() { /* * 如果头部节点存在后继节点，且节点状态为 SIGNAL(-1)，则唤醒后继节点； * 如果头部节点存在后继节点，且节点状态为默认状态 (0)， * 则为了保证唤醒操作可以正确稳定地传播下去，需要设置头部节点状态为 * PROPAGATE(-3)，这样的话，当获取锁的线程在执行 setHeadAndPropagate(Node node, int propagate) * 方法时可以读取到头部节点的 PROPAGATE(-3) 状态，从而让获取锁的线程去唤醒后继节点 */ for (;;) { // 将 h 节点的引用指向头部节点 Node h = head; /* * 如果 h 节点不为 null 且 h 节点 * 不是尾部节点 (说明 h 节点存在后继节点) */ if (h != null && h != tail) { // 获取 h 节点状态 int ws = h.waitStatus; // 如果 h 节点状态为 SIGNAL(-1) if (ws == Node.SIGNAL) { /* 使用 CAS 操作将 h 节点状态由 SIGNAL(-1) * 更新为默认状态 (0)，若操作失败则跳过本次循环 */ if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) continue; // loop to recheck cases // 唤醒后继节点 unparkSuccessor(h); } /* * 如果 h 节点状态为默认状态 (0)， * 则需要使用 CAS 操作来将 h 节点状态设置为 PROPAGATE(-3)， * 用以保证对后继节点进行唤醒传播 */ else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) continue; // loop on failed CAS } /* * 如果 h 节点仍然为头部节点，则结束循环 * 如果头部节点已改变，则重新进行循环 */ if (h == head) // loop if head changed break; } }-
唤醒头部节点的后继节点或设置头部节点状态为传播状态 (PROPAGATE(-3))
-
后继节点被唤醒后，会尝试获取共享锁，获取成功之后，又会调用
setHeadAndPropagate()方法，将唤醒操作传播下去 -
该方法保证了队列中处于等待状态的节点能够有办法被唤醒
-
-
shouldParkAfterFailedAcquire(Node pred, Node node)
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { // 获取前驱节点状态 int ws = pred.waitStatus; if (ws == Node.SIGNAL) /* * 如果前驱节点状态为 SIGNAL(-1)，则表示其在释放锁的时候 * 会去唤醒后继节点，所以此时后继节点可以阻塞自己，等待被唤醒 */ return true; if (ws > 0) { /* * 如果前驱节点状态为 CANCELLED(1)，则在队列中向前遍历， * 直到找到第一个非 CANCELLED(1) 状态的节点，并将该节点 * 设置为当前节点的前驱节点 */ do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else { /* * 如果前驱节点状态既不为 SIGNAL(-1) 也不为 CANCELLED(1)， * 则使用 CAS 操作将前驱节点状态设置为 SIGNAL(-1) */ compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false; }- 根据前驱节点状态来判断是否要阻塞当前节点
-
parkAndCheckInterrupt()
private final boolean parkAndCheckInterrupt() { // 阻塞当前线程 LockSupport.park(this); // 检查当前线程是否被中断 return Thread.interrupted(); }- 阻塞当前线程并检查其是否被中断
-
cancelAcquire(Node node)
private void cancelAcquire(Node node) { // 忽略当前节点不存在的情况 if (node == null) return; // 将当前节点的线程设置为 null node.thread = null; // 将 pred 节点的引用指向当前节点的前驱节点 Node pred = node.prev; /* * 如果前驱节点状态为 CANCELLED(1)，则在队列中向前遍历， * 直到找到第一个非 CANCELLED(1) 状态的节点，并将该节点 * 设置为当前节点的前驱节点 */ while (pred.waitStatus > 0) node.prev = pred = pred.prev; // 将 predNext 节点的引用指向 pred 节点的后继节点 Node predNext = pred.next; // 将当前节点状态设置为 CANCELLED(1) node.waitStatus = Node.CANCELLED; /* * 如果当前节点是尾部节点，且使用 CAS 操作将尾部节点 * 由当前节点更新为 pred 节点，成功后，再使用 CAS 操作 * 将 pred 节点的后继节点由 predNext 节点更新为 null * * 此时就断开了 pred 节点与其所有后继节点的联系，这些后继 * 节点在引用链上不可达，最终会被 GC 回收掉 */ if (node == tail && compareAndSetTail(node, pred)) { compareAndSetNext(pred, predNext, null); /* * 如果当前节点不是尾部节点 (即当前节点还存在着后继节点)， * 此时要做的事是将 pred 节点和当前节点的非 CANCELLED(1) * 状态的后继节点拼接起来 */ } else { int ws; /* * 如果 pred 节点不是头部节点， * 且 (pred 节点状态为 SIGNAL(-1)；或如果 pred 节点状态 * 不为 SIGNAL(-1)，则将其设置为 SIGNAL(-1)) * 且 pred 节点的线程不为 null */ if (pred != head && ((ws = pred.waitStatus) == Node.SIGNAL || (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) && pred.thread != null) { // 将 next 节点的引用当前节点的后继节点 Node next = node.next; /* * 如果 next 节点不为 null 且 next 节点状态不为 CANCELLED(1) * 则使用 CAS 操作将 pred 节点的后继节点由 predNext 节点更新为 next 节点 */ if (next != null && next.waitStatus <= 0) compareAndSetNext(pred, predNext, next); /* * 如果不满足上诉条件，则在这种情况下， * 为了保证队列的活跃性，需要去唤醒一次后继节点 * * 举例说明： * 如果 pred 节点是头部节点，则有可能当前已经 * 没有线程持有锁了，也就不会有释放锁唤醒后继节点 * 的操作，而如果不唤醒后继节点，队列就挂掉了 */ } else { unparkSuccessor(node); } /* * 将当前节点的后继节点设置为其本身，之所以不设置为 null， * 是因为为了方便 AQS 中 Condition 部分的 isOnSyncQueue 方法 * * isOnSyncQueue： * 用于判断一个原先属于条件队列的节点是否转移到了同步队列上， * 因为同步队列中会用到节点的 next 域，如果节点状态为 CANCELLED(1) * 且其 next 域也有值的话，则可以说明该节点一定位于同步队列上 * * 在 GC 层面，和设置为 null 具有相同的效果 */ node.next = node; // help GC } }- 取消当前节点获取锁的尝试
-
unparkSuccessor(Node node)
private void unparkSuccessor(Node node) { // 获取当前节点状态 int ws = node.waitStatus; /* * 如果当前节点状态不为 CANCELLED(1) 或默认状态 (0) * 则使用 CAS 操作将当前节点状态设置为默认状态 (0) */ if (ws < 0) compareAndSetWaitStatus(node, ws, 0); // 将 s 节点的引用指向当前节点的后继节点 Node s = node.next; // 如果 s 节点为 null 或 s 节点状态为 CANCELLED(1) if (s == null || s.waitStatus > 0) { // 将 s 节点设置为 null s = null; /* * 在队列中向前遍历，直到找到第一个非 CANCELLED(1) * 状态的节点并将 s 节点的引用指向该节点 */ for (Node t = tail; t != null && t != node; t = t.prev) if (t.waitStatus <= 0) s = t; } // 如果 s 节点不为 null，则将其唤醒 if (s != null) LockSupport.unpark(s.thread); }- 如果当前节点存在后继节点，则将其唤醒
2、await(long timeout, TimeUnit unit) 相关方法
-
await(long timeout, TimeUnit unit)
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout)); }-
使当前线程在锁存器倒计数为 0 之前，一直处于等待状态，除非该线程被中断或超过了指定的等待时间
-
该方法用法与
await()方法相同，只不过多了一个等待时间，其内部调用逻辑不再赘述
-
3、countDown() 相关方法
-
countDown()
public void countDown() { sync.releaseShared(1); }- 减小锁存器计数，当计数达到 0 时，释放所有等待的线程
-
releaseShared(int arg)
public final boolean releaseShared(int arg) { // 尝试释放共享锁 if (tryReleaseShared(arg)) { // 唤醒后继节点 doReleaseShared(); return true; } return false; }- 释放共享锁
-
tryReleaseShared(int arg)
protected boolean tryReleaseShared(int arg) { throw new UnsupportedOperationException(); }- 尝试释放共享锁，该方法没有具体实现，交由子类实现，此处实际调用的是 CountDownLatch 内部类 Sync 中的
tryReleaseShared(int releases)方法 (减小当前计数，如果当前计数为 0，则返回 false；如果减小后的计数为 0，则返回 true，如果不为 0，则返回 false)
- 尝试释放共享锁，该方法没有具体实现，交由子类实现，此处实际调用的是 CountDownLatch 内部类 Sync 中的
4、getCount() 相关方法
-
getCount()
public long getCount() { return sync.getCount(); }- 获取当前计数，其内部调用了 内部类 Sync 中的
getCount()方法
- 获取当前计数，其内部调用了 内部类 Sync 中的
五、举例说明
-
CountDownLatchTest.java
public class CountDownLatchTest { private void go() throws InterruptedException { CountDownLatch countDownLatch = new CountDownLatch(3); // 创建三个工作线程，并依次启动 new Thread(new CountDownLatchTask(countDownLatch), "Thread1").start(); new Thread(new CountDownLatchTask(countDownLatch), "Thread2").start(); new Thread(new CountDownLatchTask(countDownLatch), "Thread3").start(); countDownLatch.await(); System.out.println("所有工作线程已执行完毕，主线程开始执行"); } public static void main(String[] args) throws InterruptedException { new CountDownLatchTest().go(); // 线程【Thread1】执行完毕 // 线程【Thread2】执行完毕 // 线程【Thread3】执行完毕 // 所有工作线程已执行完毕，主线程开始执行 } } class CountDownLatchTask implements Runnable { private CountDownLatch countDownLatch; public CountDownLatchTask(CountDownLatch countDownLatch) { this.countDownLatch = countDownLatch; } @Override public void run() { System.out.println("线程【" + Thread.currentThread().getName() + "】执行完毕"); countDownLatch.countDown(); } }-
如上所示，调用
await()方法会阻塞主线程，此时会将主线程和共享模式 (SHARED) 包裹成一个 Node 节点，加入到 CLH 队列中，在锁存器计数为 0 之前，主线程会一直处于等待状态 -
工作线程调用
countDown()方法会减小锁存器计数，待计数为 0 时，会去唤醒等待中的主线程，使其恢复执行
-
350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
