关于java:JAVA并发编程AbstractQueuedSynchronizerAQS的实现原理

一、AQS根本介绍

同步器AbstractQueuedSynchronizer（简称AQS）是用来构建其余同步组件的根底，它应用了一个int变量来示意同步状态state，通过内置的FIFO队列来实现线程的排队工作。

二、如何应用AQS来构建同步组件？

同步器的设计是基于模板模式的，使用者继承同步器并重写指定的办法。同步器可重写的办法如下：

实现自定义同步组件时，将会调用同步器提供的模板办法，如下：

三、AQS的实现剖析

从实现角度来剖析同步器是如何实现线程同步?

1. 同步队列
2. 独占式同步状态获取与开释
3. 共享式同步状态获取与开释
4. 超时获取同步状态

3.1 同步队列

AQS外部基于同步队列（一个双向队列）来实现同步状态的治理。以后线程获取同步状态失败时，会将以后线程以及期待状态等信息结构成为一个Node节点并将其退出同步队列，同时阻塞以后线程，当同步状态开释，会把首节点中的线程唤醒，使其再次获取同步状态。

Node类构造如下：

Node节点是形成同步队列的根底，没有胜利获取同步状态的线程将会成为节点退出该队列的尾部，头节点是领有同步状态的节点。同步队列的根本构造如下：

3.2 独占式获取、开释同步状态

获取同步状态：通过调用同步器的acquire(int arg)办法获取同步状态，该办法无奈响应中断。下述代码实现了同步状态获取、节点结构、退出同步队列等相干工作。

public final void acquire(int arg) {
    if(!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    selfInterrupt();
}

流程如下：

1. 调用自定义同步器的tryAcquire(int arg)办法，该办法保障线程平安的获取同步状态，如果获取胜利，则设置独占线程为以后线程，如果获取失败，结构节点并通过addWaiter(Node node)办法将该节点退出到同步队列的尾部。
2. 接着调用acquireQueued(Node node, int arg)办法，使得节点再次尝试获取同步状态
3. 如果获取不到会调用LockSupport.park()办法阻塞以后线程，而被阻塞线程的唤醒次要依附前驱节点的出队或阻塞线程被中断来实现。
   

开释同步状态：以后线程获取同步状态并执行了相应逻辑后，就须要开释同步状态，使得后续节点可能持续获取同步状态。通过调用同步器的release(int arg) 办法就能够开释同步状态，该办法在开释同步状态后，会唤醒其后继节点。

public final boolean release(int arg) {
    if(tryRelease(arg)) {
        Node h = head;
        if(h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

总结：

1. 获取同步状态时，同步器保护一个同步队列，获取状态失败的线程会被退出到队列尾部。这里会先判断一下前驱节点是否是头节点，如果是，则尝试获取同步状态，如果获取胜利，间接将该节点设置为头节点，如果获取失败，将以后线程挂起。
2. 开释同步状态时，同步器调用release（int arg）办法开释同步状态，唤醒头节点的后继节点。

3.3 共享式获取、开释同步状态

通过调用同步器的acquireShared(int arg) 办法能够共享式地获取同步状态。

public final void acquireShared(int arg) {
    if(tryAcquireShared(arg) < 0) 
        doAcquireShared(arg);
}

private void doAcquireShared(int arg) {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        boolean interrupted = false;
        for(;;) {
            final Node p = node.predecessor();
            if(p == head) {
                int r = tryAcquireShared(arg);
                if(r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null;
                    if(interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            if(shouldParkAfterFailedAcquire(p, node) 
                && parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if(failed) {
            cancelAcquire(node);
        }
    }
}

在acquireShared(int arg)办法中，同步器调用tryAcquireShared(int arg)办法尝试获取同步状态，办法返回值为int值，如果大于等于0，示意可能获取到同步状态，反之无奈获取同步状态。在doAcquireShared(int arg)办法的自旋过程中，如果以后节点的前驱为头节点，尝试获取同步状态，如果返回值大于等于0，示意该次获取同步状态胜利并从自旋过程中退出。

与独占式一样，共享式也须要开释同步状态，通过调用releaseShared(int arg)办法能够开释同步状态。它与独占式地次要区别在于 tryReealseShared(int arg)办法必须确保同步状态平安开释，个别是通过循环+CAS来保障的。

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

3.4 超时获取同步状态

通过调用同步器的doAcquireNanos(int arg, long nanosTimeout)办法能够超时获取同步状态，在指定的时间段内获取同步状态，如果获取到则返回true，否则返回false。

超时获取同步状态过程是响应中断获取同步状态过程的升级版，doAcquireNanos办法在反对响应中断的根底上，减少了超时获取的个性，该办法提供了synchronized关键字不具备的个性。

独占式超时获取同步状态和独占式获取同步状态在流程上十分相似，次要区别在于未获取到同步状态时的解决逻辑。acquire(int arg)在未获取到同步状态时，将会使以后线程始终处于期待状态，而doAcquireNanos()办法会使以后线程期待nanosTimeout纳秒，如果以后线程在nanosTimeout纳秒内没有获取到同步状态，将会间接返回false。

四、总结

自定义同步组件可通过继承AQS并实现它的形象办法来治理同步状态。同步器既能够反对独占式地获取同步状态，也能够反对共享式地获取同步状态，来实现不同类型的同步组件（如ReentrantLock可重入锁、ReentrantReadWriteLock读写锁和CountDownLatch锁存器）