Java多线程系列--“JUC锁”09之 CountDownLatch原理和示例

概要

前面对"独占锁"和"共享锁"有了个大致的了解；和ReadWriteLock.ReadLock一样，CountDownLatch的本质也是一个"共享锁"。

 

CountDownLatch简介

CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

CountDownLatch和CyclicBarrier的区别
(01) CountDownLatch的作用是允许1或N个线程等待其他线程完成执行；而CyclicBarrier则是允许N个线程相互等待。
(02) CountDownLatch的计数器无法被重置；CyclicBarrier的计数器可以被重置后使用，因此它被称为是循环的barrier。
关于CyclicBarrier的原理，后面一章再来学习。

 

示例

CountDownLatch我理解是一个有多道锁的门闩，CountDownLatch在创建的时候就指定好有多少道锁链了。具体是这样的，假如有个门闩 CountDownLatch latch = new CountDownLatch(5)，则这个门闩上面有5道锁链，当latch == 0 的时候说明门闩上5道锁都被解开了，这时候门闩打开了。

当线程调用latch.await方法的时候，会去检查latch内锁的数量是否等于0，也就是门闩是否打开了。

如果等于0说明门闩打开了，则不会被阻塞调用线程，直接运行后面的逻辑；如果 latch > 0 比如latch == 2 说明门闩上面还有2道锁，没打开，这个时候调用latch.await方法的线程就会被阻塞。

每次调用latch.countDown方法的时候，就会去掉一道锁，所以上面latch为5的时候需要调用5次countDown方法才能去掉门闩上所有的锁，让门闩打开。

示例说明：

public class CountDownLatchDemo {
    // 创建一个有2道锁的门闩
    public static CountDownLatch latch = new CountDownLatch(2);
    
    // 等待线程，等待门闩打开
    public static class WaitLatch extends Thread {
        @Override
        public void run() {
            try {
                // 等待门闩打开
                System.out.println(Thread.currentThread().getName() + "被门闩卡住了");
                latch.await();
                // 门闩打开的时候打印一下信息
                System.out.println("门闩打开啦，" + Thread.currentThread().getName() + "通过啦");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    // 调用countDown减少门闩锁的线程
    public static class DownThread extends Thread {
        @Override
        public void run() {
            try {
                // 等3秒再去减少，让上面的WaitLatch线程先等着
                Thread.sleep(3000);
                // 减少门闩锁
                latch.countDown();
                System.out.println("释放门闩锁");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 两个等待latch打开的线程
        WaitLatch wait1 = new WaitLatch();
        WaitLatch wait2 = new WaitLatch();

        // 两个去减少latch的线程
        DownThread down1 = new DownThread();
        DownThread down2 = new DownThread();

        wait1.start();
        wait2.start();
        down1.start();
        down2.start();

        // 等待wait1、2，down1、down2线程运行结束之后，main线程再继续执行
        wait1.join();
        wait2.join();
        down1.join();
        down2.join();

        System.out.println("运行结束");
    }
}

 

 

上面的代码流程可以画一个图出来： 

 

最开始的时候wait1、wait2线程调用门闩的await方法，这个时候由于门闩上面还有2道锁，所以wait1、wait2被门闩卡住了，进入等待队列，阻塞等待门闩打开。
然后down1、down2线程分别调用countDown方法各自去掉门闩的一道锁，同时检查如果门闩上没锁了，则唤醒之前被门闩卡住的线程，让他们继续运行。

CountDownLatch的原理大致上就是这样子的，但是你知道它底层源码是怎么实现的吗？
那我就带你来分析分析CountDownLatch的底层源码

02 CountDownLatch底层源码分析

 CountDownLatch有一个内部类Sync，继承自AQS，重写了AQS的tryAcquireShared、tryReleaseShared方法，是一个共享锁。而CountDownLatch只是基于内部的Sync做了一层薄薄的封装而已。

 

 那Sync实现AQS的tryAcquireShared、tryReleaseShared的逻辑是什么呢？CountDownLatch又是基于Sync之上怎么封装的？

这个我们马上就来说，我们先来一个一个看。
CountDownLatch构造方法

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

上面的构造方法，内部其实就是创建一个Sync同步器，同时指定Sync内部的资源state == count，这里的state其实就是门闩上锁的数量。
await方法

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

内部直接调用AQS的acquireSharedInterruptibly方法，我们继续追踪：

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    // AQS这里调用子类的tryAcquireShared方法
    // 如果返回结果大于0，继续执行业务代码
    // 如果返回结果小于0，则调用doAcquireSharedInterruptibly进入AQS等待队列阻塞等待
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

看到这里，其实就清晰了，进入到AQS的acquireSharedInterruptibly方法获取一个锁，之前我们讲过AQS的acquireShared方法，跟这里是一样的，是一个模板方法。
首先第一个调用的就是子类Sync的tryAcquireShard方法去获取资源。
如果获取成功就返回了，继续执行业务代码。
如果获取失败了就调用doAcquireShardInterruptibly方法进入AQS等待队列进行等待，这里的doAcquireSharedInterruptibly的内部逻辑跟我们之前分析的doAcquireShared是一样的。

说到这里，就只剩下Sync的tryAcquireShared方法逻辑了，我们继续分析：
Sync的tryAcquireShared方法

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

 

这里非常的简单，就是state == 0的时候返回1，其它情况均返回-1。

那这么说来，搞来搞去原来调用CountDownLatch的await方法是不是会被阻塞其实还是看Sync的tryAcquireShared方法是否返回1，也就是state 是否等于0咯？

没错，上面你不是说CountDownLatch是门闩嘛，其实state == 0就代表门闩上的锁都去掉了，所以门闩就打开了。
针对上面的await方法内部的逻辑和流程，我再给你画个图总结一下：

 

 上面CountDownLatch的await方法内部的大致流程图就是这样了，你看明白了没？
大致流程是这样的吧：
调用CountDownLatch的await方法其实进入的是AQS的内部acquireSharedInterruptibly方法，这个是AQS内部定义的模板流程方法。
首先就是调用子类Sync的tryAcquireShared方法，也就是实际判断门闩是否打开，当state  == 0 表示门闩上没锁了，打开。
当state != 0 表示门闩上还有锁，这个时候就需要进入AQS的等待队列进行等待咯，等待门闩打开后将线程唤醒。
这里CountDownLacth的await方法内部的源码和流程，就讲到这里咯。我们接下来继续，讲解CountDownLatch的countDown方法：
CountDownLatch的countDown方法

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

这里的countDown方法直接就是调用AQS的releaseShared(1)方法，继续进入releaseShared方法

public final boolean releaseShared(int arg) {
    // 调用子类的tryReleaseShared方法，释放锁
    if (tryReleaseShared(arg)) {
        // 如果锁完全释放了，就唤醒等待队列中沉睡的线程
        doReleaseShared();
        return true;
    }
    return false;
}

这里就是进入AQS释放共享锁的模板流程了：
首先就是调用子类的tryReleaseShared方法释放锁，如果完全释放了，也就是state == 0 的时候，就调用AQS的doReleaseShared方法唤醒等待队列中等待的线程。
我们看看子类Sync的tryReleaseShared的逻辑
Sync的tryReleaseShared

protected boolean tryReleaseShared(int releases) {
    // Decrement count; signal when transition to zero
    for (;;) {
        int c = getState();
        // 如果state == 0，也就是锁的数量等于0，表示门闩打开了
        if (c == 0)
            return false;
         // 这里就是将state - 1，也就是将门闩上锁的数量减少一道
        int nextc = c-1;
        // CAS操作重新设置锁的数量
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

上面的代码非常简单，也就是将state的值减少1而已，表示将锁的数量减少一道。countDown内部的核心逻辑其实就是将state的数量减少1，也就是锁的数量减少1，当state == 0的时候，表示门闩已经打开，就可以调用doReleaseShared方法将AQS等待队列的线程唤醒了，表示：嘿，兄弟们，别睡了，门闩打开了。再加上doReleaseShared唤醒等待队列中的线程的源码，之前讲解AQS的共享锁机制的时候已经深入分析过了，所以这里我完全没有问题。  
从整体上画一个CountDownLatch的await方法、countDown方法的整体流程图：

 

 上面的这个图就是整体的CountDownLatch的await和countDown整体的流程以及交互的机制了，这下子CountDownLatch没问题了吧？
其实大概就是这样，最开始CountDownLatch latch = new CountDownLatch(2)的时候就是设置latch门闩上有2道锁。
然后线程A调用latch.await的时候发现上面还有锁，于是进入AQS等待队列睡觉去了。
线程B、C调用countDown方法，各自将锁减少一道，发现锁已经完全解开了，于是就是就唤醒了AQS中由于调用await方法陷入等待的线程。
这玩意，感觉就是一个计数开关一样，当门闩上锁为0的时候，开关打开，其它时候关闭，就是这么简单；只不过这东西是整合了AQS，利用了AQS的等待队列阻塞等待，以及唤醒机制而已。

CountDownLatch函数列表

CountDownLatch(int count)
构造一个用给定计数初始化的 CountDownLatch。

// 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。
void await()
// 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。
boolean await(long timeout, TimeUnit unit)
// 递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
void countDown()
// 返回当前计数。
long getCount()
// 返回标识此锁存器及其状态的字符串。
String toString()

 

CountDownLatch数据结构

CountDownLatch的UML类图如下：

CountDownLatch的数据结构很简单，它是通过"共享锁"实现的。它包含了sync对象，sync是Sync类型。Sync是实例类，它继承于AQS。

 

CountDownLatch的使用示例

下面通过CountDownLatch实现："主线程"等待"5个子线程"全部都完成"指定的工作(休眠1000ms)"之后，再继续运行。

 1 import java.util.concurrent.CountDownLatch;
 2 import java.util.concurrent.CyclicBarrier;
 3 
 4 public class CountDownLatchTest1 {
 5 
 6     private static int LATCH_SIZE = 5;
 7     private static CountDownLatch doneSignal;
 8     public static void main(String[] args) {
 9 
10         try {
11             doneSignal = new CountDownLatch(LATCH_SIZE);
12 
13             // 新建5个任务
14             for(int i=0; i<LATCH_SIZE; i++)
15                 new InnerThread().start();
16 
17             System.out.println("main await begin.");
18             // "主线程"等待线程池中5个任务的完成
19             doneSignal.await();
20 
21             System.out.println("main await finished.");
22         } catch (InterruptedException e) {
23             e.printStackTrace();
24         }
25     }
26 
27     static class InnerThread extends Thread{
28         public void run() {
29             try {
30                 Thread.sleep(1000);
31                 System.out.println(Thread.currentThread().getName() + " sleep 1000ms.");
32                 // 将CountDownLatch的数值减1
33                 doneSignal.countDown();
34             } catch (InterruptedException e) {
35                 e.printStackTrace();
36             }
37         }
38     }
39 }

运行结果：

main await begin.
Thread-0 sleep 1000ms.
Thread-2 sleep 1000ms.
Thread-1 sleep 1000ms.
Thread-4 sleep 1000ms.
Thread-3 sleep 1000ms.
main await finished.

结果说明：主线程通过doneSignal.await()等待其它线程将doneSignal递减至0。其它的5个InnerThread线程，每一个都通过doneSignal.countDown()将doneSignal的值减1；当doneSignal为0时，main被唤醒后继续执行。