juc-CountDownLatch原理分析

1 CountDownLatch简介

ps:要想理解Condition原理，需要先了解AQS，不了解AQS的可以看先之前的文章->aqs源码解析

CountDownLatch是java.util.concurrent包下一个同步工具类，它允许一个或多个线程等待直到在其他线程中一组操作执行完成。

它能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

案例：

public class countDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {

        CountDownLatch countDownLatch = new CountDownLatch(3);
        System.out.println("主线程开始运行！");
        new Thread(()->{
            System.out.println("工作线程1运行");
            countDownLatch.countDown(); // 3-1 = 2
            System.out.println("工作线程1运行结束");
        }).start();

        new Thread(()->{
            System.out.println("工作线程2运行");
            countDownLatch.countDown(); // 2-1 = 1
            System.out.println("工作线程2运行结束");
        }).start();

        new Thread(()->{
            System.out.println("工作线程运3行");
            countDownLatch.countDown(); // 1-1 = 0,当计数器为0的时候才会唤醒主线程
            System.out.println("工作线程3运行结束");
        }).start();

        countDownLatch.await();		// 主线程执行await方法，进行等待，知道计数器的值为0时继续向下执行
        System.out.println("主线程运行完成");
    }

}

运行结果：

上述代码中，为了让主线程等待工作线程执行完成，主线程调用await操作让主线程阻塞，当工作线程完成初始化过程之后，工作线程调用countDown方法时计算器为0（当计数器为0时主线程才会继续向下执行后续操作），主线程再进行后续操作。

下面我们从源码中分析其中的运行原理。

2 CountDownLatch源码分析

2.1 初始化计数器

整个过程主要是基于CountDownLatch提供的一个内部类Sync实现的，Sync继承自AbstratQueuedSynchronized（简称AQS），关于AQS可以看一下我之前对于AQS源码分析的文章。

首先从其构造方法进行分析：

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

	 Sync(int count) {
        setState(count);
     }

构造中new一个Sync对其成员变量sync进行复制（该变量使用volatile生命，保证可见性），又通过Sync的构造方法对state赋值，这里的state相当于计数器，当计数器为0的时候，唤醒等待线程。

2.2 await方法

接着我们来看await方法：

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

这里会调用内部类Sync的acquireSharedInterruptibly方法，具体如下：

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

	private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        // 将线程加入到aqs队列中
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                	// 如果计数器不等于0返回-1，如果等于0返回1
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                // 计数器不等于0，让线程阻塞
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
	
	protected int tryAcquireShared(int acquires) {
           return (getState() == 0) ? 1 : -1;
       }

先将线程加入到aqs队列中，这里面主要的逻辑在tryAcquireShared方法中，如果计数器不等于0，就让线程阻塞

2.3 countDown方法

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

	public final boolean releaseShared(int arg) {
		// 判断计数器是否等于0，如果等于0，返回true 唤醒等待中的线程
        if (tryReleaseShared(arg)) {
        	// 唤醒等待队列中的所有线程
            doReleaseShared();
            return true;
        }
        return false;
    }

	  protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            // 此时，计数器等于0，逐个唤醒等待中的线程
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                // 计数器的值 减一
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

当每次调用countDown方法的时候，会将计数器的值减一，然后判断计数器是否等于0，如果等于0，会调用doReleaseShared方法唤醒等待队列中的所有线程。