CountDownLoatch是JUC下一个用于控制计数的计数器，比如我需要从6开始计数，每个线成运行完之后计数减一，等计数器到0时候开始执行其他任务。

public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t结束");
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("开始执行新任务");
    }

现在让我们来看下CountDownLoach的底层源码

private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

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

        int getCount() {
            return getState();
        }

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

        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

    private final Sync sync;

这里最重要的是这个tyrReleaseShared方法，CountDownLatch也是实现了AQS机制，通过state去判断资源知否被占用。当我们使用countDow函数去减1时，会触发releaseShared方法，这个方法的参数时每次减的次数，默认是1

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

我们点进去看看这个方法是如何实现的

 public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

这个方法调用了AQS的releaseShared，他会先去尝试减一，判断是否减一成功

protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

这里使用了CAS自旋机制对state（我们这里是6）进行减1，如果自旋成功就会返回true即6一个一个减最后变成0，就会执行下面的doReleaseShared方法

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;
        }
    }

这里使用了LockSupport相关的加锁解锁，unpark有关这个我会在之后有空的时候进行解析，通过对AQS任务队列进行判断，是否只有头节点和尾节点，这个任务队列里面头节点并不是真正的任务，而是为了初始化方便操作的哨兵节点，然后对第一个任务节点进行操作，就是我们这6步操作，每次减一作为一个任务进行释放（我自己认为的）。

这是我第一次发帖子希望大家多多支持，准备秋招了，争取大厂上岸，如果帖子里有错误希望大家积极提出来