深入浅出多线程——ReentrantLock (一)

　　ReentrantLock是一个排它重入锁，与synchronized关键字语意类似，但比其功能更为强大。该类位于java.util.concurrent.locks包下，是Lock接口的实现类。基本用法如下：

class X {
    private final ReentrantLock lock = new ReentrantLock();
    // ...

    public void m() {
      lock.lock();  // block until condition holds
      try {
        // ... method body
      } finally {
        lock.unlock()
      }
    }
  }

　　本文章会围绕核心方法lock()，unlock()进行分析。在开始之前，对部分概念进行阐述：

　　1，RenntrantLock是一个排它重入锁，重入次数为Integer.MAX_VALUE，其中通过构造实现两大核心（公平锁，非公平锁）。在默认情况下是非公平锁。

　　2，RenntrantLock的公平锁和非公平锁基于抽象类AbstractQueuedSynchornizer，简称AQS。在源码分析阶段，也会涉及该类相关的原理分析。更加详细的会在后续文章中单独说明。

　　3，AQS中涉及到了大量的Compare and swap操作，简称CAS。CAS利用的是cpu级别原子指令无锁的去修改目标值，在并发场景下只会有一个成功。在java中有大量的应用，其中最经典的为java.util.concurrent.atomic包下的相关类。更加详细的阐述会在后续文章中单独说明。

原理分析

　　我们按照默认的不公平锁为例子进行深入。

lock()方法分析

NonfairSync.lock()

 final void lock() {
     if (compareAndSetState(0, 1))
         setExclusiveOwnerThread(Thread.currentThread());
     else
         acquire(1);
 }

　　首先去尝试将state值从0改为1，如果修改成功，把该线程设置为Owner。因为用CAS的方式去修改这个值，在并发环境下只会有一个成功。不成功的则进入acquire(1)方法。

AbstractQueuedSynchronizer.acquire(int)

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

　　该方法，首先在此尝试修改state的值，尽量用最小的代价设置成功。

具体方法代码如下：

NonfairSync.tryAcquire(int)

         protected final boolean tryAcquire(int acquires) {
             return nonfairTryAcquire(acquires);
         }

直接调用了nonfairTryAcquire(acquires)。如下：

Sync.nonfairTryAcquire(int)

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

　　首先判断state的值是否为0。如果为0，则尝试修改state为1，如果设置成功，则将执行线程Owner为当前线程。如果state不为0，则判断当前线程是否与执行线程Owner一致。如果一致则只对state加1，这个地方实现了类似偏向锁。

　　如果条件都不满足，返回false，则执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法。从里往外看，

　　首先调用的是addWaiter(Node.EXCLUSIVE)方法，该方法的参数为Node.EXCLUSIVE，表示为队列为独占模式。

AbstractQueuedSynchronizer.addWaiter(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;
     }

　　第2行代码是 创建了一个独占模式的队列节点node，通过node实现可以看出是双向链表数据结构。

　　判断列队pred是否为空，如果不为空，则node的节点prev变量设置为pred。尝试去修改列队tail的值为node，如果成功则直接返回。

　　因为第一次进入，tail肯定为空，直接执行enq(node)方法。

AbstractQueuedSynchronizer.enq(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;
                 }
             }
         }
     }

　　enq(node)方法进来是一个自旋操作，一段很经典的代码。

　　首先判断tail是否为空，因为第一次进入肯定为空。那么实例化一个空节点，将队列head，tail指向该空节点。完成该动作后再次自旋，此时tail肯定是不为空的，则直接执行else内容。

　　首先将node节点的上游指向tail后利用cas将队列tail设置为node，然后将原先的tail（t）的next指向node，此时node节点成功加入列队中。

　　再次回到acquire(1)方法，执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法。

AbstractQueuedSynchronizer.acquireQueued(Node,int)

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

　　该方法进来也是一个自旋操作，与enq方法类似。

　　第6行，node的上游此时指向的是空节点，虽然和head相等，但是由于是空线程，那么在执行tryAcquire(arg)方法肯定返回false。

　　代码直接来到了第13行，shouldParkAfterFailedAcquire(p,node)方法先执行，如下：

AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire(Node,Node)

     private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
         int ws = pred.waitStatus;
         if (ws == Node.SIGNAL)
             return true;
         if (ws > 0) {
             do {
                 node.prev = pred = pred.prev;
             } while (pred.waitStatus > 0);
             pred.next = node;
         } else {
             compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
         }
         return false;
     }

　　首先判断node的上游节点的等待状态是否为-1，因为node的上游节点是空对象，waitStatus为初始值0。该方法会直接返回运行else里面内容，将waitStatus修改为-1。

　　通过acquireQueued自旋会再次来到该方法，此时waitStatus的值为-1，返回true。然后执行第二个方法parkAndCheckInterrupt()方法。如下：

AbstractQueuedSynchronizer.parkAndCheckInterrupt()

     private final boolean parkAndCheckInterrupt() {
         LockSupport.park(this);
         return Thread.interrupted();
     }

　　进入该方法直接调用LockSupport.park(this)方法，意思是将该线程直接暂停，其线程状态在Runnable变为WAITING。等待调用LockSupport.unpark(this)将其唤醒，再次进入acquireQueued的自旋当中，直至能成功的把state的值从0变为1为止，当修改成功后，将队列的head设置为当前node。

unlock()方法分析

ReentrantLock.lock()

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

　　这个没啥好说的，直接调用了AQS里面的release方法了。

AbstractQueuedSynchronizer.release(int)

     public final boolean release(int arg) {
         if (tryRelease(arg)) {
             Node h = head;
             if (h != null && h.waitStatus != 0)
                 unparkSuccessor(h);
             return true;
         }
         return false;
     }

　　首先调用tryRelease(int)方法，尝试去释放该锁。如果释放成功，则进入if方法体，首先判断队列的head不为空，在判断head.waitStatus不为0（当前实际值为-1），则调用unparkSuccessor(Node)。

Sync.tryRelease(int)

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

　　首先将state减1后，判断是否为0，如果为0，则正式释放，如果不为0，仅仅将state的值更新。在这个方法可以反映出 lock()调用几次，必须有相应的unlock()调用次数，否则造成死锁。

AbstractQueuedSynchronizer.unparkSuccessor(int)

     private void unparkSuccessor(Node node) {

         int ws = node.waitStatus;
         if (ws < 0)
             compareAndSetWaitStatus(node, ws, 0);

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

　　首先判断node.waitStatus是否小于0，如果小于0，则将state变量修改为0。其次获取到node的下游节点，如果下游节点s 为空或者被取消，则从队列尾部向前查找符合条件的节点。如果不为空或者未被取消，则调用LockSupport.unpark(s.thread)将其唤醒。

总结

　　通过分析lock()和unlock()，我们得知AQS内部实现了一个基于双向链表的队列。发成资源竞争时，因为CAS的特性只会有一个成功，其他的均进入该队列，有点类似于synchronized的临界区。

　　执行中的线程再次调用lock()时，并不会进入等待列队，而是将state加1继续执行，基于偏向锁的思想去实现的。

　　在线程释放时，也要对应着将state进行每次减1。直到state值为0，才认为当前线程真正的释放。释放后调用当前线程的下游节点去执行，此时，因为是非公平锁的缘故，可能新加入的线程在当前线程释放时征用成功，state值又变为1。那当前线程的下游节点再次陷入WAITING状态。