ReentrantLock的原理解析

重入锁（ReentrantLock）是一种可重入无阻塞的同步机制。性能同synchronized接近（老版本jdk中性能很差）。

下面重点看下常用的lock()和unlock()方法的实现原理。

lock()

首先看下源代码：

    public void lock() {
        sync.lock();  // 有公平同步和非公平同步两种机制
    }

它的实现很简单，调用了一行sync的lock()方法，由于sync有两种实现方式：公平同步和非公平同步，默认是非公平同步，继续看代码：

final void lock() {
            if (compareAndSetState(, ))  // CAS机制，如果处于无锁状态，就直接锁定。lock锁中维护一个计数，大于0表示加锁了，值表示重入加锁次数
                setExclusiveOwnerThread(Thread.currentThread());  // 设置锁被本线程持有，有什么用呢？用于可重入时检查使用
            else　　　　
                acquire();  // 如果锁引用计数不是0，说明已经上锁，检查是否可以重入

}

继续看"acquire(1)"的实现：

    public final void acquire(int arg) {
        if (!tryAcquire(arg) && // 判断是否可以重入，即持有锁的线程是否是当前线程，如果是就把锁引用计数加1，返回lock成功
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 否则尝试把自己挂起
            selfInterrupt();
    }
　　 // 再次尝试加锁
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }

    final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();  // 锁引用计数值
            if (c == 0) {  // 为0，说明没有锁了
                if (compareAndSetState(0, acquires)) {  // 尝试加锁
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) { // 持有锁的正是当前线程，那么就把锁引用计数加1，加锁成功
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

上面看到tryAcquire中会再次尝试加锁，或者如果持有锁的是当前线程，则把锁引用计数加1，返回加锁成功。

否则执行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;  // 增加一个等待node带队尾
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
       // 前面使用CAS方式设置失败，则进入enq，循环使用CAS方式把Node加入队尾
        enq(node);
        return node;
    }
　　// 把node加入队尾
 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;
                }
            }
        }
    }
// 加入队尾后，再执行acquireQueued(即acquireQueued(addWaiter(Node.EXCLUSIVE), 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);
        }
    }

上面的代码，重点看下这两个方法：

shouldParkAfterFailedAcquire

 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
         int ws = pred.waitStatus;  // 第一次进来 ws是0，是初始值
         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 { // 设置自己的状态为Node.SIGNAL，但本次不允许挂起。下次再进来的时候，就可以返回true，并可以挂起了
             /*
              * 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;
     }

parkAndCheckInterrupt

     private final boolean parkAndCheckInterrupt() {
         LockSupport.park(this);  // 挂起自己
         return Thread.interrupted();
     }
再看下park的实现：

     public static void park(Object blocker) {
         Thread t = Thread.currentThread();
         setBlocker(t, blocker);  // 设置要挂起的线程，和挂起使用的对象
         unsafe.park(false, 0L); // 挂起，jdk内置的挂起方法
         setBlocker(t, null);      // 唤醒后，取消挂起的对象
     }

再看下setBlocker：

     private static void setBlocker(Thread t, Object arg) {
         // Even though volatile, hotspot doesn't need a write barrier here.
         unsafe.putObject(t, parkBlockerOffset, arg);
     }  // 设置了阻塞线程和使用的阻塞对象

从上面代码可以看到，lock的主要流程有：

1. 检查锁引用计数，如果为0，表示可以锁定，就使用CAS方式把当前Thread对象设置为持有锁的对象，并把锁引用计数加1.

2. 检查锁引用计数，如果大于0，需要：

    i. 检查当前持有锁的线程对象是否和本线程是同一个，如果是就对锁引用计数加1，加锁成功，这里体现了"可重入"特性。

    ii. 否则，创建一个等待的node对象并加入到等待链接的队尾，然后调用系统的unsafe.park方法，把自己挂起。

 Unlock

unlock就比较简单了，下面看下代码：

    public void unlock() {
        sync.release(1); // 解锁
    }

public final boolean release(int arg) {
        if (tryRelease(arg)) {  // 解锁
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h); // 解锁成功后，唤醒其他的等待线程
            return true;
        }
        return false;
    }

这里面重点有两个地方，一个解锁，另外一个唤醒其他等待的线程。

先看解锁：

 // 索引用计数减releases，实现了重入
 protected final boolean tryRelease(int releases) {
             int c = getState() - releases;
             if (Thread.currentThread() != getExclusiveOwnerThread())
                 throw new IllegalMonitorStateException();
             boolean free = false;
             if (c == 0) {  // 如果锁引用计数为0，说明是无锁状态了，需要把持有锁的线程变量置为空，并返回true
                 free = true;
                 setExclusiveOwnerThread(null);
             }
             setState(c);
             return free;
         }

再看唤醒其他线程代码：

 // 当前面方法返回true，说明当前处于无锁状态了，这时候就可以唤醒其他的等待线程了
 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);  // 唤醒线程
     }

相对来说，unlock就简单许多了，两步：1.解锁，减引用计数。2.唤醒其他线程。