CountDownLatch 源码详解

CountDownLatch共享锁，多个线程可以同时拿到锁。本文不讲AQS原理。

看下面一段客户端代码

 public static void main(String[] args) throws InterruptedException {
        final CountDownLatch latch = new CountDownLatch(2);
        new Thread() {
            public void run() {
                System.err.println(Thread.currentThread().getName() + " 开始计算");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.err.println(Thread.currentThread().getName() + " 计算结束");
                latch.countDown();
            };
        }.start();
        new Thread() {
            public void run() {
                System.err.println(Thread.currentThread().getName() + " 开始计算");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.err.println(Thread.currentThread().getName() + " 计算结束");
                latch.countDown();
            };
        }.start();

        System.err.println("开始等待两个子线程计算任务");
        latch.await();
        System.err.println("两个子线程计算完成，主线程返回");

    }

下面我们一步一步分析代码

第一步执行
final CountDownLatch latch = new CountDownLatch(2);
这里到底是干嘛，我们debug得到：

    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        //这里是AQS，
        this.sync = new Sync(count);
    }

上面其实就是构造了一个AQS同步器(Sync类)，为AQS的state设置为count。

  //AQS构造
  Sync(int count) {
        setState(count);
  }
  
  protected final void setState(int newState) {
        state = newState;
    }

第二步执行 ： latch.await();
执行完这个await，我们主线程就会阻塞住（直到两个线程都执行完countDown，才返回）。

我们继续debug进去

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

public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
}

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

先判断state是不是0 ，如果是0就直接返回了， 如果不是0 ，将执行doAcquireSharedInterruptibly(1) 方法，联系上文此时我们的state值是2的。

 private void doAcquireSharedInterruptibly(int arg) {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                //返回前驱节点
                final Node p = node.predecessor();
                if (p == head) {
                    //state=2 ，返回 -1
                    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);
        }
    }

首先执行 final Node node = addWaiter(Node.SHARED); 这段代码就是干了下面图这个事情。

• 构造了三个node节点。
• 头节点(node1)值都为null，但是next值node2节点。
• node2就是main线程占用的节点，thread指向Main线程，nextWaiter为SHARED模式节点。
  

接着执行： final Node p = node.predecessor();
返回pre前驱节点，也就是上图中的node1节点。

接着执行： tryAcquireShared，也就是

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

此时 state=2 ， 所以返回 -1

接下来 执行shouldParkAfterFailedAcquire ，注意只是第一次循环

//pred就是我们的node1节点
//node就是我们的node2节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL) // -1
            return true;
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
           //把 pred(node1)的 waitStatus 变成 -1
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

第一次循环就是把node1节点的waitStatus变成-1 。

接下来进入doAcquireSharedInterruptibly方法的第二次循环 ,代码还是贴一下

 private void doAcquireSharedInterruptibly(int arg) {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                //返回前驱节点
                final Node p = node.predecessor();
                if (p == head) {
                    //state=2 ，返回 -1
                    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);
        }
    }

第二次进入shouldParkAfterFailedAcquire方法， 这个地方就是 -1 ，返回了true

返回true 就执行了 LockSupport.park(this); 阻塞了当前main线程。

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

到此我们还只分析了 latch.await(); 真的是太难了

我们在来分析 线程A， 和线程B 调用 latch.countDown();

    public void countDown() {
        sync.releaseShared(1);
    }
    
  public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

先 调用 tryReleaseShared(1) ， 去释放一个锁， 就是把state值减1。如果是减到0了，就返回true ， 如果本身state就是0 就返回false 。

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

再回头看 releaseShared 方法， tryReleaseShared返回false就什么都不做，直接返回， 否则就执行doReleaseShared

 private void doReleaseShared() {
        for (;;) {
            Node h = head;//node1节点
            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;
        }
    }

我们来温习下 latch.await(); 生成的数据结构 ：

doReleaseShared 方法就是 把node1 的waitStatus 改成 0 。 然后 调用 unparkSuccessor去唤醒 等待的节点。

 private void unparkSuccessor(Node node) {
 		// node就是node1节点  ws此时为0
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        Node s = node.next; //node2节点
        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;
        }
        //唤醒 Main线程 
        if (s != null)
            LockSupport.unpark(s.thread);
    }

到此我们做个总结：

await内部实现流程:

• 判断state计数是否为0，不是，则直接放过执行后面的代码 大于0，则表示需要阻塞等待计数为0。
• 当前线程封装Node对象，进入阻塞队列。
• 然后就是循环尝试获取锁，直到成功（即state为0）后出队，继续执行线程后续代码。

countDown内部实现流程:

• 尝试释放锁tryReleaseShared，实现计数-1。
• 若计数已经小于0，则直接返回false，否则执行计数(AQS的state)减一，若减完之后，state==0，表示没有线程占用锁，即释放成功，然后就需要唤醒被阻塞的线程了。
• 释放并唤醒阻塞线程 doReleaseShared。
• 如果队列为空，即表示没有线程被阻塞（也就是说没有线程调用了 CountDownLatch#wait()方法），直接退出。
• 头结点如果为SIGNAL, 则依次唤醒头结点下个节点上关联的线程，并出队。