十八. CountDownLatch源码简析

小咪咪 2024-03-30 17:38 70阅读 0赞

### 前言 ###

`CountDownLatch`是`JDK`提供的同步工具，可以实现让一个线程等待其它一组线程执行完毕，然后再继续往下执行的功能。本篇文章将对`CountDownLatch`的内部原理进行分析。

### 正文 ###

`CountDownLatch`内部有一个静态内部类`Sync`继承了`AbstractQueuedSynchronizer`，在`CountDownLatch`初始化时就会创建`Sync`对象，后续的功能也是依靠`Sync`对象实现。下面先看一下`CountDownLatch`的**UML**图。

![在这里插入图片描述][d951714a79774503a29d7e8cbadbf19d.jpeg_pic_center]

`CountDownLatch`的构造方法如下所示。

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

继续看`Sync`的构造函数，如下所示。

Sync(int count) {
        
        // 将count值赋值给AbstractQueuedSynchronizer的state字段
        setState(count);
    }

`setState()`方法是`AbstractQueuedSynchronizer`提供的方法，其作用是设置`AbstractQueuedSynchronizer`的**state**字段的值，所以创建`CountDownLatch`对象后，与这个`CountDownLatch`对象关联的`AbstractQueuedSynchronizer`的**state**值会被设置为创建`CountDownLatch`对象时指定的**count**值。

下面再分析`CountDownLatch`的`await()`方法，如下所示。

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

`CountDownLatch`的`await()`方法会调用到`AbstractQueuedSynchronizer`的`acquireSharedInterruptibly()`方法，其实现如下。

public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        
        if (Thread.interrupted())
            throw new InterruptedException();
        // 调用AbstractQueuedSynchronizer子类实现的tryAcquireShared()方法
        if (tryAcquireShared(arg) < 0)
            // 如果tryAcquireShared()方法返回值小于0，则入同步队列并进入共享式阻塞状态
            doAcquireSharedInterruptibly(arg);
    }

`AbstractQueuedSynchronizer`的`acquireSharedInterruptibly()`方法会先调用其子类`Sync`实现的`tryAcquireShared()`方法，如果`tryAcquireShared()`方法返回值小于0，则调用`AbstractQueuedSynchronizer`的`doAcquireSharedInterruptibly()`方法将当前线程入同步队列并进入共享式阻塞状态。那么`CountDownLatch`的`await()`方法能够共享式阻塞调用该方法的线程，关键就在于`Sync`实现的`tryAcquireShared()`方法，其实现如下。

protected int tryAcquireShared(int acquires) {
        
        // state为0时返回1，语义就是不用入同步队列并共享式阻塞
        // state非0时返回-1，语义就是要入同步队列并共享式阻塞
        return (getState() == 0) ? 1 : -1;
    }

在 `Sync`实现的`tryAcquireShared()`方法中就是对**state**值进行判断，只要非0就会返回-1，从而让调用`CountDownLatch`的`await()`方法的线程入同步队列并共享式阻塞，而已知`CountDownLatch`在初始化时会设置**state**的值，所以只要设置的**state**的值大于0，并且没有其它线程调用`CountDownLatch`的`countDown()`方法，那么`CountDownLatch`的`await()`方法就会共享式阻塞调用线程。

有了阻塞，就会有唤醒，下面看一下`CountDownLatch`的`countDown()`方法。

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

在`CountDownLatch`的`countDown()`方法中会调用`AbstractQueuedSynchronizer`的`releaseShared()`方法，其实现如下所示。

public final boolean releaseShared(int arg) {
        
        // 调用AbstractQueuedSynchronizer子类实现的tryReleaseShared()方法
        // tryReleaseShared()方法返回true时就调用AbstractQueuedSynchronizer的doReleaseShared()方法
        if (tryReleaseShared(arg)) {
        
            // 共享式的释放同步状态，会依次唤醒在同步队列上共享式阻塞的线程
            doReleaseShared();
            return true;
        }
        return false;
    }

`AbstractQueuedSynchronizer`的`releaseShared()`方法中会先调用`AbstractQueuedSynchronizer`的子类`Sync`实现的`tryReleaseShared()`方法，该方法如果返回**true**，就会调用`AbstractQueuedSynchronizer`的`doReleaseShared()`方法来共享式唤醒线程，下面先分析一下`Sync`实现的`tryReleaseShared()`方法，如下所示。

protected boolean tryReleaseShared(int releases) {
        
        for (;;) {
        
            int c = getState();
            // 如果当前state已经为0，则不允许继续减1
            if (c == 0)
                return false;
            // 基于CAS的方式让state减1
            int nextc = c-1;
            if (compareAndSetState(c, nextc))
                // state减1后如果等于0就返回true
                // 否则返回false
                return nextc == 0;
        }
    }

`Sync`的`tryReleaseShared()`方法在**state**减1后等于0时会返回**true**，也就是说在唤醒线程时，**state**的值为0。现在继续分析唤醒线程的`AbstractQueuedSynchronizer#doReleaseShared`方法，该方法会共享式的释放同步状态，然后唤醒在同步队列上共享式阻塞的线程，唤醒后的线程会先调用`AbstractQueuedSynchronizer`的子类实现的`tryAcquireShared()`方法来共享式获取锁，如果该方法返回1，则表明共享式获取锁成功并且锁还可以继续被获取，此时唤醒的操作会传递下去。先看一下`Sync`的`tryAcquireShared()`方法的实现。

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

上面提到，唤醒线程时，**state**的值为0，所以此时调用`tryAcquireShared()`方法会一直返回1，则唤醒同步队列上共享式阻塞的线程的这个操作会依次传递下去，最终所有因为调用`CountDownLatch`的`countDown()`方法而共享式阻塞在同步队列上的线程都会被唤醒。

### 总结 ###

1.  `CountDownLatch`初始化时传入的**count**值必须大于等于0，当**count**等于0时，可以完成初始化，但是后续调用`CountDownLatch`的`await()`方法时，不会阻塞调用线程；
2.  通过调用`CountDownLatch`的`await()`方法而被阻塞的线程，是共享式阻塞状态；
3.  通过调用`CountDownLatch`的`countDown()`方法而使**count**值等于0时，此时会共享式的依次唤醒所有因为调用`CountDownLatch`的`await()`方法而共享式阻塞的线程。

[d951714a79774503a29d7e8cbadbf19d.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/39cf43ea14244947a4fa282d577003b1.jpeg