聊聊ReentrantLock的内部实现

　　大家都用过ReentrantLock，但是大家对内部实现是否足够了解呢，下面我就简单说一下其中的实现原理。

　　ReentrantLock是可重入锁，也就是同一个线程可以多次获取锁，每获取一次就会进行一次计数，解锁的时候就会递减这个计数，直到计数变为0。

　　它有两种实现，一种是公平锁，一种是非公平锁，那么默认是什么锁呢？看完如下代码想必你也知道了。　　

/**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

　　它的内部结构的实现是如何的呢? 首先NonFairSync类是静态内部类，它继承了Sync。

/**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync

　　Sync继承了AbstractQueuedSynchronizer，简称AQS。同时Sync里边实现了tryRelease方法，因为公平锁和非公平锁都可以用这个方法释放锁。

/**
     * Base of synchronization control for this lock. Subclassed
     * into fair and nonfair versions below. Uses AQS state to
     * represent the number of holds on the lock.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer 

　　继续看非公平锁的lock方法，采用CAS进行当前状态的设置state=0，表示没有线程占用，state=1表示已经有现成占用了，设置成功了，将当前线程设置为线程拥有者，并且是排他的。如果有现成占用了，那么需要进入acquire(1)，需要获取一个锁。

/**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

　　acquire方法首先进行tryAcquire，尝试获取锁，即调用nonfairTryAcquire，判断当前锁是否state=0, 则没有现成占用，则进行设置。如果被占用了判断该线程是否是当前线程占用的，如果是的话，那么可以进行重入，即当前可以获取锁，计数器进行加1。否则的话返回失败。返回失败后执行addWaiter方法，也就是添加到等待的队列。Node是一个双向列表，也就是把需要等待的线程放到放到Node，并且链接起来。

            /**
     * Acquires in exclusive mode, ignoring interrupts.  Implemented
     * by invoking at least once {@link #tryAcquire},
     * returning on success.  Otherwise the thread is queued, possibly
     * repeatedly blocking and unblocking, invoking {@link
     * #tryAcquire} until success.  This method can be used
     * to implement method {@link Lock#lock}.
     *
     * @param arg the acquire argument.  This value is conveyed to
     *        {@link #tryAcquire} but is otherwise uninterpreted and
     *        can represent anything you like.
     */
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

        /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        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;
        }
        
    /**
     * 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;
    }

　　接下来看一下Node的大致内容，有两个指针，一个是prev，一个是next，还保存着当前的线程。同时里边还有一个共享锁和独占锁，SHARED和EXCLUSIVE。ReentrantLock采用的就是独占锁。Semaphore，CountDownLatch等采用的是共享锁，即有多个线程可以同时获取锁。

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;
        /**
         * Link to predecessor node that current node/thread relies on
         * for checking waitStatus. Assigned during enqueuing, and nulled
         * out (for sake of GC) only upon dequeuing.  Also, upon
         * cancellation of a predecessor, we short-circuit while
         * finding a non-cancelled one, which will always exist
         * because the head node is never cancelled: A node becomes
         * head only as a result of successful acquire. A
         * cancelled thread never succeeds in acquiring, and a thread only
         * cancels itself, not any other node.
         */
        volatile Node prev;

        /**
         * Link to the successor node that the current node/thread
         * unparks upon release. Assigned during enqueuing, adjusted
         * when bypassing cancelled predecessors, and nulled out (for
         * sake of GC) when dequeued.  The enq operation does not
         * assign next field of a predecessor until after attachment,
         * so seeing a null next field does not necessarily mean that
         * node is at end of queue. However, if a next field appears
         * to be null, we can scan prev's from the tail to
         * double-check.  The next field of cancelled nodes is set to
         * point to the node itself instead of null, to make life
         * easier for isOnSyncQueue.
         */
        volatile Node next;

        /**
         * The thread that enqueued this node.  Initialized on
         * construction and nulled out after use.
         */
        volatile Thread thread;

        /**
         * Link to next node waiting on condition, or the special
         * value SHARED.  Because condition queues are accessed only
         * when holding in exclusive mode, we just need a simple
         * linked queue to hold nodes while they are waiting on
         * conditions. They are then transferred to the queue to
         * re-acquire. And because conditions can only be exclusive,
         * we save a field by using special value to indicate shared
         * mode.
         */
        Node nextWaiter;

　　大致的思路我们看了一下，总体的流程图我画了一下。ReentrankLock内核采用的是AQS实现的，AQS里边采用的是双向链表，即如果当前线程未获取到锁将会加入到链表中。

　　那么公平锁和非公平锁的实现的不同点在哪里呢？公平锁和非公平锁就差在 !hasQueuedPredecessors() ，也就是前边没有排队者的话，我就可以获取锁了。

/**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

　　如果当前线程之前还有线程等待就会返回true，如果当前节点是头结点，或者当前队列为空就会返回false。非公平锁没有这句话的判断，所以直接去竞争锁。

   /**
     * Queries whether any threads have been waiting to acquire longer
     * than the current thread.
     *
     * <p>An invocation of this method is equivalent to (but may be
     * more efficient than):
     *  <pre> {@code
     * getFirstQueuedThread() != Thread.currentThread() &&
     * hasQueuedThreads()}</pre>
     *
     * <p>Note that because cancellations due to interrupts and
     * timeouts may occur at any time, a {@code true} return does not
     * guarantee that some other thread will acquire before the current
     * thread.  Likewise, it is possible for another thread to win a
     * race to enqueue after this method has returned {@code false},
     * due to the queue being empty.
     *
     * <p>This method is designed to be used by a fair synchronizer to
     * avoid <a href="AbstractQueuedSynchronizer#barging">barging</a>.
     * Such a synchronizer's {@link #tryAcquire} method should return
     * {@code false}, and its {@link #tryAcquireShared} method should
     * return a negative value, if this method returns {@code true}
     * (unless this is a reentrant acquire).  For example, the {@code
     * tryAcquire} method for a fair, reentrant, exclusive mode
     * synchronizer might look like this:
     *
     *  <pre> {@code
     * protected boolean tryAcquire(int arg) {
     *   if (isHeldExclusively()) {
     *     // A reentrant acquire; increment hold count
     *     return true;
     *   } else if (hasQueuedPredecessors()) {
     *     return false;
     *   } else {
     *     // try to acquire normally
     *   }
     * }}</pre>
     *
     * @return {@code true} if there is a queued thread preceding the
     *         current thread, and {@code false} if the current thread
     *         is at the head of the queue or the queue is empty
     * @since 1.7
     */
    public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

　　这个就是ReentrantLock的基本原理，接下来咱们继续看看与之一块使用的Condition。Condition是一个接口，它的实现类是ConditionObject。调用await的时候也会将当前线程的一些信息加入到队列当中。ConditionObject中有一个firstWaiter和LastWaiter分别指向的了等待队列的头和尾。

　　当调用Condition的signal方法是，则会将第一个Node转换到同步队列，如下图所示。

　　好了，总结一下：

　　1. ReentrankLock默认是非公平锁。

　　2.ReentrankLock的内部实现采用的AQS的双向链表实现。获取锁的线程会被封装成Node里边，供后续使用。

　　3.公平锁采用判断当前Node是不是头结点，如果是的话就获取锁并做业务处理，不是头结点的不能获取所。

　　4.非公平锁没有判断当前结点，采用CAS，谁第一个拿到了state=0,则视为获取锁。

　　5.Condition的await和notify也采用类似的机制，当执行await是，会将当前线程信息的相关信息放入到Node的列表，记录firstWaiter和lastWaiter指向的信息。

　　

　　希望对大家有所帮助，如果有问题的请及时指出。