深入浅出多线程——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状态。