Java中的锁（七）

本章主要介绍Java中的计数器CountDownLatch。

一、CountdownLatch的基本概念

countdownLatch也叫闭锁，与cyclicBarrier一样，也是在jdk1.5中的并发包引入的。CountDownLatch内部会维护一个初始值为线程数量的计数器，主线程执行await方法，如果计数器大于0，则阻塞等待。当一个线程完成任务后，计数器值减1。当计数器为0时，表示所有的线程已经完成任务，等待的主线程被唤醒继续执行。

public class CountdownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i=0; i<5; i++){
            final int finalI = i;
            Runnable task = () ->{
                try {
                    Thread.sleep(1000);
                    System.out.println("task "+ finalI +" execute finish");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
            };
            exec.submit(task);
        }
        System.out.println("主线程等待......");
        System.out.println(latch.toString());
        latch.await();
        System.out.println(latch.toString());
        System.out.println("主线程继续.......");
    }
}

可以明确的是：主线程调用await方法进行阻塞，一直到latch的计数减为0后被唤醒。

二、CountdownLatch的底层实现

countdownLathch提供一个构造函数，public CountDownLatch(int count)，参数count表示需要多少个线程先执行完成才会唤醒主线程。内部是通过AQS实现阻塞和释放锁。

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

    // 阻塞方法
    public void await() throws InterruptedException;
    // 超时阻塞方法
    public boolean await(long timeout, TimeUnit unit) throws InterruptedException;
    // 计数减一
    public void countDown() {
        sync.releaseShared(1);
    }

    public long getCount() { return sync.getCount();}
}

加锁的过程：

// 加入同步等待队列
public void await() throws InterruptedException {
   sync.acquireSharedInterruptibly(1);
}
// 调用到AQS的等待，允许中断
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
   if (Thread.interrupted())
      throw new InterruptedException();
   if (tryAcquireShared(arg) < 0)
      doAcquireSharedInterruptibly(arg);
}

// 通过自己的Sync方法判断是否允许加入等待，如果计数不等于0，就加入同步队列
protected int tryAcquireShared(int acquires) {
   return (getState() == 0) ? 1 : -1;
}

// AQS 加入同步队列方法，并且唤醒队列中的头部节点
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);
     }
}

 解锁的过程：

private static final class Sync extends AbstractQueuedSynchronizer {
    // 设置AQS的状态    
    Sync(int count) { setState(count);}

    int getCount() { return getState();}

    protected int tryAcquireShared(int acquires) {
       return (getState() == 0) ? 1 : -1;
    }
    // 每次释放的时候，都会通过CAS对state进行修改
    // 当计数为0的时候，才会尝试唤醒同步队列中的节点对应的线程
    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;
        }
    }
}

// 执行计数减一
public void countDown() { sync.releaseShared(1);}

// 调用AQS释放同步状态
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
         doReleaseShared();
         return true;
    }
    return false;
}

// 通过自旋的方式，唤醒同步队列中节点
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;
    }
}

综上，countDownLatch的工作过程是：首先设置AQS的state状态，主线程调用await()方法，加入到同步等待队列中，并进行阻塞；任务线程调用countDown方法，每调用一次，state自减1，当减到值为0的时候，唤醒同步队列中的节点，然后主线程执行任务。