JUC包之AbstractQueuedSynchronizer源码学习

AQS是JUC包的基础，几乎所有的JUC工具类，都是用了AQS进行实现，AQS使用了CLH lock的队列作为基础，关于CLH，前文有一篇转载的又说到什么事CLH lock，AQS中的CLH,其实就是一个FIFO的队列，队列中的每个结点（线程）只要等待其前继释放锁就可以了。这是JDK内画的 一张图：

   * <pre>
     *      +------+  prev +-----+       +-----+
     * head |      | <---- |     | <---- |     |  tail
     *      +------+       +-----+       +-----+
     * </pre>

这张图简单的说明了AQS内部阻塞队列的实现，这里省略了next指向下一节点的指针，只是标识出了pre指向前继的指针。

要看AQS，还要先从内部Node节点类说起。

static final class Node {
        /** Marker to indicate a node is waiting in shared mode */
        static final Node SHARED = new Node();
        /** Marker to indicate a node is waiting in exclusive mode */
        static final Node EXCLUSIVE = null;

        /** waitStatus value to indicate thread has cancelled */
        static final int CANCELLED = 1;
        /** waitStatus value to indicate successor's thread needs unparking */
        static final int SIGNAL = -1;
        /** waitStatus value to indicate thread is waiting on condition */
        static final int CONDITION = -2;
        /**
         * waitStatus value to indicate the next acquireShared should
         * unconditionally propagate
         */
        static final int PROPAGATE = -3;

        volatile int waitStatus;

        volatile Node prev;

       
        volatile Node next;

        
        volatile Thread thread;

        
        Node nextWaiter;

    
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        Node() { // Used to establish initial head or SHARED marker
        }

        Node(Thread thread, Node mode) { // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

Node保留了前继prev和后继next指针，以及对象Thread，同时有两个Node类型的标记值SHARED和EXCLUSIVE标记模式是互斥的还是共享的。我们还可以看到一个waitStatus字段，默认有四种值：

CANCELLED = 1 说明此节点对应的线程已经取消

SIGNAL = -1 说明后继节点的线程（successor's thread）需要unparking

CONDITION = -2，说明此线程正在某个条件上阻塞

PROPAGATE = -3，下个共享获取请求必须无条件通过

Node用来作为queue队列节点，同时存储了阻塞的线程，并且用不同的状态和字段标识更多的信息。AQS队列是一个FIFO先进先出的队列。

我们再来看下AQS类自身，

    
    <div>  private transient volatile Node head;</div><div>
</div><div>    /**
     * Tail of the wait queue, lazily initialized.  Modified only via
     * method enq to add new wait node.
     */
    private transient volatile Node tail;</div><div>
</div><div>    /**
     * The synchronization state.
     */
    private volatile int state;</div>

这是AQS自身的三个属性，其中state尤为重要，很多工具类都是对state的值进行不同定义而实现不同的功能的。比如信号量和可重入互斥锁等。

这是节点入队方法，不用细说：

  /**
     * Inserts node into queue, initializing if necessary. See picture above.
     * @param node the node to insert
     * @return node's predecessor
     */
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

    /**
     * Creates and enqueues node for current thread and given mode.
     *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
     */
    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

AQS还有一个很重要的工具类，LockSupport，后面我们会用到，关于此类，可以参考博客http://www.cnblogs.com/zhanjindong/p/java-concurrent-package-aqs-locksupport-and-thread-interrupt.html。

我们看下AQS下的unparkSuccessor(Node node)方法：

 //Wakes up node's successor, if one exists. /*当prev节点为signal时，说明下一个节点需要被unparking，这此方法并没有限制为signal，直接unparking*/

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)//若状态值为负数，则置为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) {//下个节点为null或状态值>0，则从tail节点开始向前遍历，找到第一个状态值<=0的，并unpark此节点的线程
            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);
    }

看下互斥下阻塞获取方法：

 public final void acquire(int arg) {
        if (!tryAcquire(arg) &&   //addWaiter将创建新节点，添加到阻塞队列
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();//调用线程的中断方法
    }

其中tryAcquire方法只是抛出了异常，强制子类去实现此方法，AQS保留了

 protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

  protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }

  protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }

等方法去让子类去实现。

tryAcquire(arg)获取失败后， 将线程添加到阻塞队列。

 final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {

		//获取节点的前继
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {//经过上述循环，阻塞队列都不满足，则取消此次请求
            if (failed)
                cancelAcquire(node);
        }
    }

在调用addWaiter将线程添加到阻塞队列之后，进行recheck，获取node的前继，若是head节点且tryAcquire获取资源成功，则将head出队列，并将此节点设置为head节点。

 /**
     * Checks and updates status for a node that failed to acquire.
     * Returns true if thread should block. This is the main signal
     * control in all acquire loops.  Requires that pred == node.prev.
     *
     * @param pred node's predecessor holding status
     * @param node the node
     * @return {@code true} if thread should block
     */
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)//前继节点状态为signal，说明后继可以等待unparking，将后继park
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {//前继已经取消，往前遍历，知道状态！>0,将遍历后的节点next指向此节点，去掉刚才的已取消节点
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {//状态值要么为初始化的0，要么为PROPAGATE，重置为signal，让后继通过前继的signal，表明自己等待unparking
            /*
             * 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;
    }

   private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();//将线程的中断状态返回并且清零
    }

继续看下释放操作：

    /**
     * Releases in exclusive mode.  Implemented by unblocking one or
     * more threads if {@link #tryRelease} returns true.
     * This method can be used to implement method {@link Lock#unlock}.
     *
     * @param arg the release argument.  This value is conveyed to
     *        {@link #tryRelease} but is otherwise uninterpreted and
     *        can represent anything you like.
     * @return the value returned from {@link #tryRelease}
     */
    public final boolean release(int arg) {
        if (tryRelease(arg)) {//如果tryRelease释放成功，则将head出队
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);//找到满足条件的最靠近head的后继节点并unpark
            return true;
        }
        return false;
    }