CountDownLatch源码分析

CountDownLatch简介

简介：CountDownLatch是基于AQS共享锁的一个锁工具，用来线程同步问题，针对的是一个线程必须等待多个线程完成后才运行的场景，count就是代表线程的个数。

CountDownLatch基于AQS的共享锁，如果你对这块知识还不了解，可以看我之前写的文章：AQS源码详细分析，让你掌握AQS原理，独占锁、共享锁、Conditio

CountDownLatch举例

package juc;

import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch {

    public static void main(String[] args) {
        final CountDownLatch countDownLatch = new CountDownLatch(2);

        new Thread(){
            @Override
            public void run() {

                System.out.println("线程1准备");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1结束");
                countDownLatch.countDown();
               
            }
        }.start();

        new Thread(){
            @Override
            public void run() {

                System.out.println("线程2准备");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2结束");
                countDownLatch.countDown();
            }
        }.start();

        new Thread(){
            @Override
            public void run() {

                try {
                    System.out.println("开始等待线程1、线程2");
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("线程1、线程2准备完毕");
            }
        }.start();


    }
}

CountDownLatch源码分析

CountDownLatch结构
首先看下CountDownLatch的结构

从上图可以看出，CountDownLatch的构造方法只有一个CountDownLatch(int count)就是设置共享锁同时可以容纳的线程数。

CountDownLatch内部实现了一个Sync，Sync继承于AQS，并且是共享锁模式。

1、初始化

public CountDownLatch(int count) {
    //如果小于0，抛出参数异常
    if (count < 0) throw new IllegalArgumentException("count < 0");
    //初始化共享锁AQS
    this.sync = new Sync(count);
}

//将Sync从AQS继承的count，设置为count、
Sync(int count) {
    setState(count);
}

2、await()

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

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    //如果被中断，抛出异常
    if (Thread.interrupted())
        throw new InterruptedException();
     //申请共享锁，申请成功就返回
    if (tryAcquireShared(arg) < 0)
        //如果申请失败，就尝试入队挂起
        doAcquireSharedInterruptibly(arg);
}

protected int tryAcquireShared(int acquires) {
    //等于0返回1，不等于0返回-1
    return (getState() == 0) ? 1 : -1;
}

private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    //之前AQS时说过，将thread包装为Node入队，不再详细叙述
    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);
    }
}

await()十分简单，如果state==0，就返回，如果不等于0，就挂起，
相当于共享锁中的抢锁过程。

3、countDown()

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

public final boolean releaseShared(int arg) {
	//释放锁
    if (tryReleaseShared(arg)) {//当所有线程都调用countDown()后，state等于0，唤醒等待的线程，
        doReleaseShared();
        return true;
    }
    return false;
}

protected boolean tryReleaseShared(int releases) {
 
    // 利用CAS自旋，知道CAS将state-1，如果state为0，返回true，不为0，返回false。
    //当所有线程都调用countDown()后，state等于0。
    for (;;) {
        int c = getState();
        if (c == 0)
            return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}


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;                、
        }
        if (h == head)                   
            break;
    }
}

unparkSuccessor(h)

unparkSuccessor(h)中会调用

LockSupport.unpark(s.thread);

唤醒线程，会回到之前await()阻塞的地方。

private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    //之前AQS时说过，将thread包装为Node入队，不再详细叙述
    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())
                //这里这里这里这里
                //线程被唤醒，停止阻塞如果线程被中断的话，就抛出异常
                //如果线程不被中断，就自旋去请求锁，请求锁成功然后返回
                //await调用完成，返回
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

总结

从上述代码可以看出，一个线程调用countDown()会将state-1。

await的作用就是当state！=0的时候，线程会阻塞，也就是当count个线程成功调用countDown()后，state会等于0，await()会停止阻塞。

所以说CountDownLatch可以适用于一个线程等待若干个线程的场景。

TIP

1、当线程调用countDown()后，不会阻塞，会继续执行代码。
2、CountDownLatch只能使用一次，不可重复利用。

如果你了解了AQS的共享锁的原理，理解CountDownLatch毫无压力。
AQS里面还是有很多经典的思想的，感兴趣的同学可以看我之前写的AQS的文章：AQS源码详细分析，让你掌握AQS原理，独占锁、共享锁、Conditio