ReentrantLock、AbstractQueuedSynchronizer解读

在使用ReentrantLock时，我们首先调用的是ReentrantLock类的lock()方法，ReentrantLock内部维护着一个Sync同步对象，该对象继承了AbstractQueuedSynchronizer（以下简称AQS）抽象类。在创建ReentrantLock类时创建了这个Sync同步对象，ReentrantLock的构造方法如下：

    public ReentrantLock() {

        sync = new NonfairSync();

    }

Sync类有两个子类， FairSync和NonfairSync。

也可以调用重载的构造方法

    public ReentrantLock(boolean fair) {

        sync = fair ? new FairSync() : new NonfairSync();

    }

来制定Sync同步对象是公平锁还是非公平锁，默认的话就是非公平的，我们拿默认的非公平锁来说，调用这个NonfairSync对象的lock()方法，代码如下

        final void lock() {

            if (compareAndSetState(0, 1))

                setExclusiveOwnerThread(Thread.currentThread());

            else

                acquire(1);

        }

首先cas算法尝试将AbstractQueuedSynchronizer的state状态从0设置为1，如果设置成功将AbstractQueuedSynchronizer的exclusiveOwnerThread属性设置成当前的线程，exclusiveOwnerThread属性代表的就是当前持有锁的线程对象，当前线程就获得了锁并返回。

如果compareAndSetState(0, 1)没有执行成功的话就往下进行else中的操作，调用AbstractQueuedSynchronizer类的acquire(1)方法，代码如下：

    public final void acquire(int arg) {

        if (!tryAcquire(arg) &&

            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

            selfInterrupt();

    }

acquire()方法首先调用了tryAcquire(1)来获取锁，这个方法是AbstractQueuedSynchronizer中定义的抽象方法，由子类NonfairSync来实现的，代码如下：

        protected final boolean tryAcquire(int acquires) {

            return nonfairTryAcquire(acquires);

        }

他又调用了父类Sync的nonfairTryAcquire(1)方法，该方法代码如下：

        final boolean nonfairTryAcquire(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;

        }

首先拿到AbstractQueuedSynchronizer的state属性看看判断c == 0如果是的话就在尝试cas设置状态，设置成功就返回，如果不成功要看看当前的线程是不是当前锁的持有者(可重入的处理)，如果是的话就将AQS的state属性递增，返回。

如果c!=0当前线程也不是当前所的持有者的话就返回false。

接下来我们又回到了AQS的acquire(1)方法

    public final void acquire(int arg) {

        if (!tryAcquire(arg) &&

            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

            selfInterrupt();

    } 

如果tryAcquire(1)获取成功直接返回，如果不成功依次执行addWaiter(Node.EXCLUSIVE), ,acquireQueued()两个方法，我们逐一往下看：

Node类是AQS类中的内部类代表了一个双向链表中的节点对象，Node有一下几种类型，代表了Node节点的等待状态，对应了Node类的waitStatus属性的值，这个属性是valitile类型的变量：

        /** waitStatus value to indicate thread has cancelled */

        static final int CANCELLED = 1; 取消状态，即被取消了获取所得操作，是在获取锁过程中出现异常时设置的，可以理解只要waitStatus>0就是取消状态的节点

        /** 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; //条件等待状态的节点，说明创建了Condition对象

        /**

         * waitStatus value to indicate the next acquireShared should

         * unconditionally propagate

         */

        static final int PROPAGATE = -3;

Node.EXCLUSIVE的值为null

addWaiter方法的代码如下：

    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;

    }

acquire方法传递过来的mode为null，

Node node = new Node(Thread.currentThread(), mode);代码创建了一个Node对象注意这里的Node对象waitStatus状态是默认值0，接下来将尾节点赋值给pred属性，如果尾节点不是null说明已经有其他的线程在排队获取锁，就将新创建的Node的pre节点设置成tail节点，并cas尝试设置新创建的节点为尾节点，如果创建成功则放回新创建的这个节点，如果不成功接着往下走。

从上面的逻辑中发现如果尾节点是null(说明没有节点在等待获取锁，条件1)或者是尾节点不是null但是cas尝试将当前新创建的节点设置成尾节点的时候失败（即存在竞争，在竞争中失败，条件2）都会往下继续执行，就到了enq(node);代码段，下来我们来分析enq方法，传入的参数就是新创建的这个节点。代码如下：

    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;

                }

            }

        }

    }

enq()方法是一个自旋的方法，如果尾节点是null(和上文第一个条件1对应),新创建一个节点并cas算法设置为头结点，如果设置成功就将头结点设置为尾节点，循环继续执行，如果此时存在竞争总会有一个线程设置成功，其他的线程和设置成功的线程也都会进入到else里面，继续将传入的节点依次的往双向链表上设置设置成功返回，这样不论多少个线程进入该方法存在多么激烈的竞争，自旋的enq方法执行完以后都会形成一个双向的链表，并返回传入节点的前驱节点。enq()方法执行完addWaiter()方法也就分析完成了，addWaiter()方法返回了在addWaiter方法中新创建的节点。

接下来分析acquireQueued方法，传入的参数依次是addWaiter(Node.EXCLUSIVE)方法中返回的新创建的节点和参数1。acquireQueued代码如下：

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

        }

    }

acquireQueued方法也是一个自旋的方法，首先如果传入的node节点的前驱节点是head节点，就尝试执行NonfairSync类实现的tryAcquire（1）方法，前面已经分析过这个方法了，就是尝试设置AQS的state属性获取锁，如果设置成功了就将头结点设置成自己，当前节点的前驱设置成null，当前节点的thread属性设置为null，原来头结点的后继节点设置为null返回。如果没有设置成功或者当前传入节点的父节点不是头结点则接着往下执行shouldParkAfterFailedAcquire（）方法，传入的参数依次为传入节点的父节点和传入的节点，代码如下：

    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;

    }

如果前驱节点的waitStatus状态为Node.SIGNAL（前面说过这个状态）返回true，如果waitStatus>0（前面说过，代表取消状态）就要尝试将从前驱节点开始的所有前驱节点中waitStatus>0（代表取消状态）的节点干掉。

如果前驱节点不是Node.SIGNAL状态，并且前驱节点的waitStatus不大于0(非取消状态)则cas算法尝试将前驱节点的waitStatus状态设置为Node.SIGNAL状态(噢，原来waitStatus的状态是在这里设置的啊)waitStatus状态设置为volitile的类型的也是为了这里设置成功之后所有的线程都能看得到。都执行完了返回false。这个方法执行完成之后链表的状态如下所示(后面的数字代表等待状态waitStatus的值)：

head(-1)

node1(-1)

node2(-1)

node3(-1)

node4(-1)

node5(-1)

node6(-1)

tail(0)

如果返回了false前面acquireQueued（）方法还要再次尝试获取锁的操作。

如果返回true则继续执行parkAndCheckInterrupt()方法，这里会调用 LockSupport.park(this);方法将当前线程挂起为Waiting状态，等待锁释放后的信号通知。

到此为止加锁的过程就分析的差不多了。

接下来看看AQS的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;

    }

首先调用Sync类的tryRelease方法，

        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的state状态设置为0，AQS中的锁持有线程设置为null，返回True。释放成功之后就是通知等待双端队列中的第一个等待(waitStatus状态为Node.SIGNAL)的节点。unparkSuccessor方法如下所示，传入的节点是头结点：

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

    }

如果头结点的后继节点的waitStatus>0就要从尾节点开始向前找到一个待通知的节点调用LockSupport.unpark(s.thread);方法唤醒等待的线程，被唤醒的线程就在上文分析的parkAndCheckInterrupt（）方法中被唤醒后回到acquireQueued方法获取到了锁。

待解决问题：如下所示双向等待链表状态的release()操作会不会把node6(-1)唤醒

head(-1)

node1(1)

node2(-1)

node3(-1)

node4(-1)

node5(-1)

node6(-1)

tail(0)