AQS

AQS(AbstractQueuedSynchronizer)顾名思义，抽象的队列同步器。

它是JUC中大部分同步工具的基础。如：CountDownLatch/FutureTask/ReentrantLock/RenntrantReadWriteLock/Semaphore。

它更是一个模板模式的典型应用。接下来就主要阐述这个模板的主要流程。

首先从结构来简单介绍一下AQS，代码如下

class aqs{
　　// 表示线程对资源的占有状态
　　int state;
　　// 线程悬停队列的头指针与尾指针
    Node head;　　
    Node tail;
　　
　　// 双向链表
　　static class Node{
　　　　
　　　　int waitStatus;　　/*
　　　　　　　　　　　　　　　　　　-1(SIGNAL): 表示下一个节点的线程需要被释放
　　　　　　　　　　　　　　　　　　1(CANCELLED): 当前节点的线程已被标志为退出状态
　　　　　　　　　　　　　　　　　　-2(CONDITION): 用于条件队列
　　　　　　　　　　　　　　　　　　-3(PROPAGATE): 共享状态的中间状态
　　　　　　　　　　　　　　　　　　0(None): None of the above
　　　　　　　　　　　　　　　*/
　　　　Node prev;
　　　　Node next;
　　　　Thread thread;
　　}
}

刚刚就有提及AQS就是模板模式实现的。而模板模式的核心则是流程的制定。而aqs的主流程：

 Acquire:
     while (!tryAcquire(arg)) {
        enqueue thread if it is not already queued;
        possibly block current thread;
     }

 Release:
     if (tryRelease(arg))
        unblock the first queued thread;

 上述代码就包含了流程中最重要的4个方法:

• acquire        循环调用tryAcquire, 失败则阻塞, 并进入线程队列
  
• tryAcquire   试图获取资源(通过设定aqs的state属性) 
• release        释放资源, 释放成功则唤醒线程队列中的第一个节点线程
• tryRelease   试图释放资源(与tryAcquire相反)

我们通过非公平锁的简单实现来看一下整个流程的细节:

class UnfairLock {
    private final Sync sync = new Sync();
    
    void lock() {
        sync.lock();
    }
    
    void unlock() {
        sync.release(1);
    }
    
    /**
        通过继承aqs实现一个同步工具,
        通常只需实现tryAcquire与tryRelease, (在独占模式下, 其实是必须实现. 独占模式等下会再详说)
    */
    static class Sync extends AbstractQueuedSynchronizer {
        void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        
        /**
         *    试图获取锁资源(即将sync的state属性设置为非0)
         */
        final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            //  第一次获取锁
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 锁重入
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            // 获取失败
            return false;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {    // 释放资源成功
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
    }
}

 从上面的实现便可以看到AQS的acquire与release方法的重要性了。我们再来看看它们的具体实现。

acquire的实现：

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&        // 试图获取资源失败
        /**
            addWaiter方法, 生成一个新的线程节点, 并加入线程队列. 
            acquireQueued, 核心方法, (自旋等待, 阻塞都在这个方法实现) 并返回该线程是否在等待时有被中断.
        */
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            // 如果该线程在等待时被中断, 传递中断信号
            selfInterrupt();
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {    
            /**
                自旋等待, 
                直到首节点被通知(WaitStatus必须为SIGNAL), 
                并唤醒第二节点的线程. (这里就可以看到SIGNAL的作用: 表示下一节点的线程可以安全的被park, 因为该节点已经处于等待信号状态了, 这个等待信号指的是unparkSuccessor(node)的调用)
                被唤醒后, 该节点则被置为首节点.
            */
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            /**
                shouldParkAfterFailedAcquire 
                    如果前置节点(p)已经被设置为SIGNAL信号, 则表示该线程可以被悬停, 则通过parkAndCheckInterrupt()中的LockSupport.lock()实现悬停
                    否则设置一次前置节点(p)为SIGNAL, 再次循环验证
            */
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

 release的实现：

public final boolean release(int arg) {
    if (tryRelease(arg)) {        // 试图释放资源
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);    // 通知头结点
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}

了解了acquire和release的实现， aqs模板的流程就已经十分清晰了。总结来说： 请求线程通过acquire去获取资源，获取成功则占有资源并返回，失败则进入线程队列进行悬停等待。直到持有资源的线程通过release方法通知线程队列。

然后就是对队列的维护工作了。注意：所有维护工作都是通过CAS（Compare and Swap）实现的。这是JUC的核心。

但是这个其实说的是独占模式下的流程。aqs还有个共享模式，原理是类似的， 区别只有一些细节上的实现。

/**
    acquire
*/
public final void acquireShared(int arg) {
    /**
        共享模式资源可能会被几个线程同时占有，
        aqs的state属性在这表示剩余可被占有的资源的数量
        因此如果可被占有的少于0，则会进入悬停等待队列
    */
    if (tryAcquireShared(arg) < 0)
        /**
            类似之前的acquireQueued的，
            循环通过tryAcquireShared去获取资源，
            并悬停等待
        */
        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; // help GC
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}


private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    setHead(node);
    /*
     * Try to signal next queued node if:
     *   Propagation was indicated by caller,
     *     or was recorded (as h.waitStatus either before
     *     or after setHead) by a previous operation
     *     (note: this uses sign-check of waitStatus because
     *      PROPAGATE status may transition to SIGNAL.)
     * and
     *   The next node is waiting in shared mode,
     *     or we don't know, because it appears null
     *
     * The conservatism in both of these checks may cause
     * unnecessary wake-ups, but only when there are multiple
     * racing acquires/releases, so most need signals now or soon
     * anyway.
     */
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}


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


private void doReleaseShared() {
    /*
     * Ensure that a release propagates, even if there are other
     * in-progress acquires/releases.  This proceeds in the usual
     * way of trying to unparkSuccessor of head if it needs
     * signal. But if it does not, status is set to PROPAGATE to
     * ensure that upon release, propagation continues.
     * Additionally, we must loop in case a new node is added
     * while we are doing this. Also, unlike other uses of
     * unparkSuccessor, we need to know if CAS to reset status
     * fails, if so rechecking.
     */
    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;
    }
}

aqs还有一个很巧妙的实现： ConditionObject。它是作为内部类实现的。

/**

　　最重要的两个方法， 主流程

　　

　　独占模式与共享模式

　　

　　Condition

*/