面试集中营—AQS哪些事儿之CountDownLatch

AQS中的一些问题

        上一章面试集中营—AQS哪些事儿之ReentrantLock-CSDN博客 我们讲了AQS的原理和ReentrantLock原理，本章我们先讲几个功能点，同时简单的分析一下CountDownLatch的原理。

1、state为什么是int不是boolean类型？

        AQS既可以用来实现互斥锁也可以用来实现共享锁，互斥锁确实可以用boolean来定义state的类型，但是共享锁需要多个线程持有一个锁资源，那么boolean就不适合了，state定义成int类型可以表示线程占用的数量。

2、为什么要有一个虚拟的head节点?

         AQS有一个状态SIGNAL ，如果是 -1，表示：当当前节点释放锁的时候，需要唤醒下一个节点。所有，每个节点在休眠前，都需要将前置节点的 ws 设置成 SIGNAL，否则自己就永远无法被唤醒，而刚插入的节点是没有前置节点的，这就需要一个虚拟节点。 

3、为什么选择使用双向链表，而不是单向链表?

        使用双向链表作为等待队列的底层数据结构，是为了提供高效的队列操作，保持线程等待的有序性，同时支持在节点之间传播状态信息，从而实现了 AQS 的核心同步机制。这种设计使得 AQS 能够灵活地支持各种同步器的实现。

4、 插入新的node是头插还是尾插？唤醒线程为什么从尾节点从后往前找？

       肯定是尾插，因为这个队列是先进先出的。

       第二个问题如果面试官这么问，要么就是自己不太懂要么就是在挖坑，因为我们通过源码，并不是直接从尾结点开始找。正常的流程应该是当前节点在释放了锁以后，优先找自己的下一个节点，当下一个节点出现异常的时候，才从尾节点从后往前找。具体的原因有两点：

      1、节点取消后，后置节点会置为Null，如果从前往后找遇到null就可能会中断；

      2、插入新节点的时候，会先构建前驱节点的指针，同时通过cas去修改后置节点的指针，所以也会出现后置节点为空的情况，同样会造成死锁。

      综合以上两点，从后往前找一定能找到一个可用的节点，或者一定能遍历到所有的节点。

CountDownLatch

        我们看下如下源码，和上一章（）相同也是持有了一个静态内部类Sync的实例。这个Sync有一个默认的构造函数，传入一个int字段count，我们看到实际上更新的是AQS里面的state字段

public class CountDownLatch {
    /**
     * Synchronization control For CountDownLatch.
     * Uses AQS state to represent count.
     */
    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;

        这个state表示的就是一共要同步的数量，我们来看下几个重要的方法

 countDown方法

        这个方法就是把state的值减一

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

        AQS中

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

        tryReleaseShared实现是在CountDownLatch 中的，主要的功能就是在不断地尝试把state值减一，并返回。如果当前state已经是0了，就返回false，如果在减一后state值为0表示已经全部完成了，返回true否则返回false

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

    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();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

        这里又调回到CountDownLatch中，看到就是对比当前state是否为0,0就返回1，不是0就返回-1；这里我们要讲解一下返回值，如果返回是负数表示获取锁失败，如果返回0表示获取锁成功同时不唤醒下个进程，如果返回正数，表示获取锁成功同时唤醒下个进程。CountDownLatch中只有-1和1就是因为不需要返回0。

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

        看一下获取锁失败的时候doAcquireSharedInterruptibly方法，这个方法的代码如下：

    /**
     * Acquires in shared interruptible mode.
     * @param arg the acquire argument
     */
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        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);
        }
    }

        上面这段代码，就不详细描述了，大家可以参考 面试集中营—AQS哪些事儿之ReentrantLock-CSDN博客 这篇文章的相关内容