CountDownLatch 源码讲解

老规矩，先翻译源码。

CountDownLatch 是一种同步辅助工具，允许一个或多个线程等待其他线程中正在执行的一组操作完成。

CountDownLatch是用给定的count参数初始化实例。 await方法会一直阻塞到当前计数为零，当调用countDown方法会释放所有等待的线程，await方法的任何后续调用都将立即返回。这是一种一次性现象——无法重置计数。如果需要重置计数的版本，请考虑使用CyclicBarrier类（这个类下次讲解）。

CountDownLatch是一种通用的同步工具，可用于多种用途。CountDownLatch是以计数初始化为1的作为简单的 on/off 的锁或者门，所有调用await方法的线程在门处等待，直到它被调用countDown方法的线程打开。初始化CountDownLatch 为N的数量实例可用于使一个线程等待N个线程完成某个操作，或某个操作已完成N次，然后再解锁。

CountDownLatch 一个实用的特性是它不要求所有调用countDown方法的线程等待计数达到零，而是简单地阻止任何线程通过之前想要越过await方法执行其他操作的线程。

示例用法：

其中一组工作线程使用两个countDownLatche

第一个是启动信号，防止任何Worker继续工作，直到driver准备好让他们继续工作。

第二个是完成信号，driver一直等待到所有Worker都完成才能继续。

class Driver { 
    void main() throws InterruptedException {
      CountDownLatch startSignal = new CountDownLatch(1);
      CountDownLatch doneSignal = new CountDownLatch(N);
       for (int i = 0; i < N; ++i) // create and start threads
        new Thread(new Worker(startSignal, doneSignal)).start();
       doSomethingElse();            // don't let run yet
      startSignal.countDown();      // let all threads proceed
      doSomethingElse();
      doneSignal.await();           // wait for all to finish
    }
  }
   class Worker implements Runnable {
    private final CountDownLatch startSignal;
    private final CountDownLatch doneSignal;
    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
      this.startSignal = startSignal;
      this.doneSignal = doneSignal;
    }
    public void run() {
      try {
        startSignal.await();
        doWork();
        doneSignal.countDown();
      } catch (InterruptedException ex) {} // return;
    }
     void doWork() { ... }
  }
}

另一个典型的用法是将一个问题分成N个部分，用每个执行该部分的Runnable来描述每个部分，并在加锁进行倒数，然后将所有的Runnable排队执行。当所有子部分完成时，协调线程将能够通过await。（当线程必须以这种方式重复倒数时，请使用 CyclicBarrier。）下面就是例子：

class Driver2 { // ...
    void main() throws InterruptedException {
      CountDownLatch doneSignal = new CountDownLatch(N);
      Executor e = ...
       for (int i = 0; i < N; ++i) // create and start threads
        e.execute(new WorkerRunnable(doneSignal, i));
       doneSignal.await();           // wait for all to finish
    }
  }
   class WorkerRunnable implements Runnable {
    private final CountDownLatch doneSignal;
    private final int i;
    WorkerRunnable(CountDownLatch doneSignal, int i) {
      this.doneSignal = doneSignal;
      this.i = i;
    }
    public void run() {
      try {
        doWork(i);
        doneSignal.countDown();
      } catch (InterruptedException ex) {} // return;
    }
     void doWork() { ... }
  }
}

内存一致性影响：在计数为零之前，线程中调用 countDown() 之前的操作 happen-before 在从另一个线程中对应 await() 成功返回的操作。（这句话有点难以理解，我的理解是 当 线程A 调用 countDown(),线程B调用await(),如果Count 是1的话，那么当count因为 线程A countDown（）变为0，线程B 就相当于可见线程A的当前处理状态，然后继续执行自己下面的操作。）

OK 以上就是源码的翻译，现在知道CountDownLatch的用法和限制，那么我们就来看看CountDownLatch具体源码是如何实现它的功能的。

首先从构造方法看起

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

可以看到，有个Sync接收count,那么看下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) {
  return (getState() == 0) ? 1 : -1;
}

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

可以看到Sync 是继承 AbstractQueuedSynchronizer(AQS),也就是利用AQS的state 作为count控制。

那么接下来看下主要方法，上面提到的countDown和await 具体实现吧。

首先看下await方法。

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

可以看到await具体实现是靠acquireSharedInterruptibly实现的，这个方法如果看过我写的Semaphore 源码分析 应该知道，它的acquire实现也是acquireSharedInterruptibly靠这个控制的。那么我们继续往下看

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

可以看到tryAcquireShared这个是在Sync重写了。

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

也就是看下目前state是否是0，不是0就返回-1. OK 接下来看doAcquireSharedInterruptibly吧。

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

这个方法是作用是以共享可中断模式获取。那么是怎么实现呢？

首先通过 addWaiter(Node.SHARED)，添加当前线程到AQS的队列中。

然后再进行一次tryAcquireShared，如果成功了，就是返回，如果继续不成功，就走了

shouldParkAfterFailedAcquire和parkAndCheckInterrupt方法。

shouldParkAfterFailedAcquire方法就是 检查并更新失败的节点的状态获取。就是验证下当前线程是否正常，并纠正不正常的当前线程状态，并返回flase进行重新尝试获取state。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
   int ws = pred.waitStatus;
   if (ws == Node.SIGNAL)
     return true;
   if (ws > 0) {
     do {
       node.prev = pred = pred.prev;
     } while (pred.waitStatus > 0);
     pred.next = node;
   } else {
     compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
   }
   return false;
 }

parkAndCheckInterrupt 是方法进行park休眠 并且判断是否线程中断。

private final boolean parkAndCheckInterrupt() {
   LockSupport.park(this);
   return Thread.interrupted();
 }

OK 那么await 就说完了，是不是跟Semaphore的acquire很像。

接下来看下countDown方法吧。

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

这个方法内容是不是跟Semaphore的release一模一样 ：），但是 这个是AQS的releaseShared方法，那继续看

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

tryReleaseShared方式Sync类进行重写了。

protected boolean tryReleaseShared(int releases) {
  for (;;) {
    int c = getState();
    if (c == 0)
      return false;
    int nextc = c-1;
    if (compareAndSetState(c, nextc))
      return nextc == 0;
  }
}

比较简单，就是获取state，如果等于0就返回false；其他情况就是减一，然后cas修改，返回如果nextc不为0就为false，否则true。

下一个就是看doReleaseShared方法啦。

 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;           
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;               
            }
            if (h == head)                  
                break;
        }
    }

把源码翻译下：

共享模式的释放操作——向后继者发出信号并确保传播。（注意：对于独占模式，如果需要信号，释放相当于调用head的unparkSuccessor。）

确保一个发布可以传播，即使有其他正在进行的获取/发布。这是按照通常的方法进行的，如果头部需要信号，则尝试断开处理器的连接。但如果没有，则将status设置为PROPAGATE，以确保在发布时继续传播。此外，我们必须循环以防在执行此操作时添加新节点。另外，与unparkSuccessor的其他用法不同，我们需要知道CAS重置状态是否失败，如果是，则重新检查。

OK 看不懂没关系，CountDownLatch的NODE是 SIGNAL，可以看上文的保存，所以关注点看unparkSuccessor方法就好。

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;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

可以看到waitStatus其实在上面 doReleaseShared 已经改成0了，所以忽略。

下一个逻辑就是将next 休眠唤醒，unpark的线程被保存在后续节点中，后者通常只是下一个节点。但如果取消或明显为空，则从尾部向后遍历，以找到实际未取消的后继项。

现在CountDownLatch流程就说完了，如果看了我之前写的Semaphore 源码分析那么就会发现2者其实底层控制是相似的，只是重写了一个方法就变成另一个作用，所以源码其实就是这么简单。