ReentraintLock及AbstractQueueSychronizer

ReentraintLcok与AQS

我们都知道RenentraintLock实现了公平锁与非公平锁，同时是可重入的。其实ReentraintLock的大部分功能都是基于AQS来实现的。在ReentraintLock类的内部存在这一个静态抽象内部类Sync,该类便是继承自AQS，同时还存在static final 的内部类FairSync和NonfairSync，这两个类继承自Sync类，同时实现了各自版本的tryAcquire()方法。从上面两个内部类的名字可以看出，FairSync对应着公平锁的实现，NonfairSync对应着非公平锁的实现，同时也可以发现，公平锁与非公平锁的差别主要是在tryAcquire()方法上。

加锁的过程

下面我们以公平锁为例讲解ReentraintLock加锁的过程
1. 初始化ReentraintLock
从代码可以看出，ReentraintLock类有两个构造函数以此来区分实现公平锁或者非公平锁。

public ReentrantLock() {
        sync = new NonfairSync();
    }
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

2.锁的获取，执行lock()加锁其实就是调用了Sync的实现类FairSync的lock函数。

final void lock() {
            acquire(1);
        }
/**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */

上面的lock()方法调用了AQS中的acquire()方法

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

在acquire()方法中有几个主要的函数tryAcquire,acquireQueue以及addWaiter方法，首先我们分析下tryAcquire()，它的具体实现是在FairSync类中。

 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();//返回的是定义在AQS中的volatile变量state
            if (c == 0) {//如果state变量为0，说明并没有线程占用
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    //主要在这里体现了公平锁和非公平锁的区别，（当前代码是公平锁）如果队列中没有其他的元素（Node节点，封装了线程信息以及状态信息），利用CAS的机制尝试改变state的值，如果修改成功则设置锁被当前线程占用。
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
            //如果state的状态不为0，说明锁已经被占用，如果锁被占用的线程是当前的线程，可以通过增加state的值实现重入的功能。
                int nextc = c + acquires;
                if (nextc < 0)//锁的占用超过了int的最大值
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);//更新state值，这里不需要通过CAS的机制更新
                return true;
            }
            return false;
        }

通过以上代码及分析，如果当前线程获取锁成功返回true，否则返回false。
我们继续看AQS中的acquire方法，如果锁占用成功函数直接返回，如果占用失败，则会将当前线程的相关信息添加到队列中，然后将线程park。
3. AQS中的线程队列
在分析锁占用失败的线程入队操作之前，我们先来看一下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;

       ........
    }

Node类中比较重要的两个点，一个是内部的node对象表示当前是独占锁还是共享锁，另一个便是node节点的几种状态，用waitstatus来表示。抢占锁失败的线程会封装成node节点存储中AQS中的队列中。接下来我们分析acquireQueue以及addWaiter方法。

private Node addWaiter(Node mode) {
// 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)) {//利用cas机制将当前node设置为tail尾节点，如果设置成功则节点入队成功，返回当前节点；否则执行enq()函数。
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

下面是enq（）方法，该方法也是AQS中的方法，通过自旋+CAS的方式实现入队操作

private Node enq(final Node node) {
        for (;;) {//这里通过自旋+CAS的方式入队
            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;
                }
            }
        }
    }

在队列刚组建的时候，head节点是一个没有意义的节点（没有封装线程信息，节点状态默认为0），后续为head节点的next节点挤掉，然后head节点代表的其实就是当前占用锁的线程。
接下来，我们看下acquireQueue()方法

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)) {
                //如果head节点是队列最初创建的无意义的空接点（如果上文中所说），会被node节点挤掉，因为state的值为0，tryAcquire如果修改state值成功就会将node节点作为新的节点
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

从上面的代码看出，只有当前线程真证获取到锁之后才会成功的退出for()循环。如果获取锁失败会调用shouldParkAfterFailedAcquire(p, node)，通过LockSupport中的park()函数将当前对象park掉，不再占用CPU的时间片，然后head节点的对应线程释放锁后会将其后续节点唤醒（唤醒是根据head节点的waitstatus来操作的）

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            //如果node节点的前继节点状态是signal，那前继节点的线程释放锁的时候会唤醒该节点，可以直接返回。
            return true;
        if (ws > 0) {
        //ws大于0，说明线程被取消，然后从当前节点开始，从前继节点中寻找第一个waitStatus中<=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);
            //修改pred节点的waitstatus值
        }
        return false;
    }

当线程被Park后，可能通过三种方式被唤醒，有可能被当前线程节点的前继节点调用unpark（）唤醒，或者其他线程对当前线程进行中断操作，或者一些其他的原因导致线程被唤醒。