JAVA 并发类（六） ReentrantLock 源码分析

ReentrantLock实现了Lock接口，是一种递归无阻塞的同步机制。

首先ReentrantLock有公平锁和非公平锁机制，使用构造方法ReentrantLock(boolean)指定，默认是非公平锁。

公平锁的含义是线程按照发出请求的先后顺序获取锁，而非公平锁的机制下，线程可以插队，后到的线程可以直接跳到队列头部获得锁

================================================

ps:前天看到有同学提问为什么非公平锁的效率比公平锁的效率高？
原因是在恢复一个被挂起的线程到该线程真正运行之间存在着延迟

举个栗子，假设线程A持有锁，线程B请求该锁，由于锁已经被占用，B被阻塞挂起，知道A释放锁时才会唤醒B，然后B才会重新尝试去获取该锁。但是此时，如果线程C也请求这个锁，那么如果是非公平锁的话，C会在B被完全唤醒之前或者使用以及释放该锁，这样B获得锁的时间没有推迟，而C也更早的获得了锁，并且吞吐量提高了，当然这是在C持有锁时间较短的情况下，如果线程持有锁的情况较长应该使用公平锁，OVER

=================================================

继续：
ReentrantLock内有三个内部类，分别是Sync,FairSync和NoFairSync，其中FairSync和NoFairSync是Sync的子类。

/** * 该锁同步控制的一个基类.下边有两个子类：非公平机制和公平机制.使用了AbstractQueuedSynchronizer类的 */static abstract class Sync extends AbstractQueuedSynchronizer/** * 非公平锁同步器 */final static class NonfairSync extends Sync/** * 公平锁同步器 */final static class FairSync extends Sync

因此使用ReentrantLock的加锁lock操作时，又分为了两种情况，分别是公平锁的lock和非公平锁的lock;

非公平锁的核心思想

1.基于CAS尝试把锁数量从0设置为1
2.如果设置成功，当前线程为独占锁的线程
3.设置失败，会再次尝试获取锁数量
4.如果锁数量为0，再基于CAS尝试把锁数量从0设置为1，如果设置成功，当前线程为独占锁的线程
5.如果锁数量不为0，查看当前线程是不是已经是独占锁的线程了，如果是，则将当前的锁数量+1；如果不是，则将该线程封装在一个Node内，并加入到等待队列中去。等待被其前一个线程节点唤醒。

非公平锁源码分析

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

首先通过CAS操作尝试把锁数量从0设置为1，如果成功，当前线程为独占锁的线程，否则执行一个acquire(1)方法

我们下面看acquire(1)的具体实现

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

先调用了tryAcquire方法 看非公平锁中的具体实现

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

再次获取当前的锁数量，如果锁数量为0，表示没有线程持有锁，那么再尝试把当前state设置为1，如果设置成功，那么当前线程就持有该锁，返回true;
锁数量不为0话，意味着有线程持有该锁，判断是否是当前线程持有[可重入]，是的话把当前锁数量+1，否则的话返回false.
此时tryAcquire(1)方法返回false,会继续执行 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法，而又先调用了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; if (pred != null) {     node.prev = pred;     if (compareAndSetTail(pred, node)) {         pred.next = node;         return node;     } } enq(node); return node;}

这个方法把当前线程封装成一个Node对象，然后把Node加入等待队列。可以看到代码上的注释写着：先尝试快速入队，快速入队失败就尝试普通入队方法
根据代码看到，快速入队就是使用CAS操作尝试把尾节点tail设置成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;          }      }  }}

如果尾节点为空，进行初始化，如果非空，就一直CAS循环到node插入到队尾为止

队列入队成功后返回node节点，我们再回到acquireQueued方法

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

获取node的前驱节点p，如果p是头节点，就继续使用tryAcquire(1)方法去尝试请求成功，如果第一次请求就成功，不用中断自己的线程，如果是之后的循环中将线程挂起之后又请求成功了，使用selfInterrupt()中断自己

如果p不是头节点，或者tryAcquire(1)请求不成功，就去执行shouldParkAfterFailedAcquire(Node pred, Node node)来检测当前节点是不是可以安全的被挂起，如果node的前驱节点pred的等待状态是SIGNAL（即可以唤醒下一个节点的线程），则node节点的线程可以安全挂起。如果node的前驱节点pred的等待状态是CANCELLED，则pred的线程被取消了，我们会将pred之前的连续几个被取消的前驱节点从队列中剔除，返回false。

如果node的前驱节点pred的等待状态是除了上述两种的其他状态，则使用CAS尝试将前驱节点的等待状态设为SIGNAL，并返回false（因为CAS可能会失败，这里不管失败与否，都返回false，下一次执行该方法的之后，pred的等待状态就是SIGNAL了）

如果可以安全挂起，就执行parkAndCheckInterrupt()挂起当前线程

最后，直到该节点的前驱节点p之前的所有节点都执行完毕为止，我们的p成为了头节点，并且tryAcquire(1)请求成功，跳出循环，去执行

看下Node节点的具体结构

/*** 同步等待队列（双向链表）中的节点 */static final class Node {    /** 线程被取消了 */    static final int CANCELLED = 1;    /**      * 如果前驱节点的等待状态是SIGNAL，表示当前节点将来可以被唤醒，那么当前节点就可以安全的挂起了      * 否则，当前节点不能挂起      */    static final int SIGNAL = -1;    /**线程正在等待条件*/    static final int CONDITION = -2;    /**     * waitStatus value to indicate the next acquireShared should     * unconditionally propagate     */    static final int PROPAGATE = -3;    /** Marker to indicate a node is waiting in shared mode */    static final Node SHARED = new Node();    /** 一个标记：用于表明该节点正在独占锁模式下进行等待 */    static final Node EXCLUSIVE = null;    //值就是前四个int（CANCELLED/SIGNAL/CONDITION/PROPAGATE），再加一个0    volatile int waitStatus;    /**前驱节点*/    volatile Node prev;    /**后继节点*/    volatile Node next;    /**节点中的线程*/    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;    /**     * Returns true if node is waiting in shared mode     */    final boolean isShared() {        return nextWaiter == SHARED;    }    /**     * 返回该节点前一个节点     */    final Node predecessor() throws NullPointerException {        Node p = prev;        if (p == null)            throw new NullPointerException();        else            return p;    }    Node() { // Used to establish initial head or SHARED marker    }    Node(Thread thread, Node mode) { // 用于addWaiter中        this.nextWaiter = mode;        this.thread = thread;    }    Node(Thread thread, int waitStatus) { // Used by Condition        this.waitStatus = waitStatus;        this.thread = thread;    }}

公平锁的核心

获取一次锁数量

1.如果锁数量为0，如果当前线程是等待队列中的头节点，基于CAS尝试将state（锁数量）从0设置为1一次，如果设置成功，设置当前线程为独占锁的线程；

2.如果锁数量不为0或者当前线程不是等待队列中的头节点或者上边的尝试又失败了，查看当前线程是不是已经是独占锁的线程了，如果是，则将当前的锁数量+1；如果不是，则将该线程封装在一个Node内，并加入到等待队列中去。等待被其前一个线程节点唤醒。

        /**         * 获取公平锁的方法         * 1）获取锁数量c         * 1.1)如果c==0，如果当前线程是等待队列中的头节点，使用CAS将state（锁数量）从0设置为1，如果设置成功，当前线程独占锁-->请求成功         * 1.2)如果c!=0，判断当前的线程是不是就是当下独占锁的线程，如果是，就将当前的锁数量状态值+1（这也就是可重入锁的名称的来源）-->请求成功         * 最后，请求失败后，将当前线程链入队尾并挂起，之后等待被唤醒。         */        protected final boolean tryAcquire(int acquires) {            final Thread current = Thread.currentThread();            int c = getState();            if (c == 0) {                if (isFirst(current) && 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;        }

如果请求失败也是把线程放入队尾挂起等待唤醒，和非公平锁一样

总结二者的区别

公平锁的lock加锁少了插队部分(CAS尝试把state从0设置为1从而获得锁的过程)
公平锁的tryAcquire有判断当前线程是否在等待队列队首的逻辑
ReentrantLock是基于AbstractQueuedSynchronizer实现的，AbstractQueuedSynchronizer可以实现独占锁也可以实现共享锁，ReentrantLock只是使用了其中的独占锁模式

---

前面介绍了ReentrantLock的公平锁和非公锁的加锁机制，下面再简单说下解锁机制。
首先解锁的流程：
1.获取当前的锁数量，然后用这个锁数量减去解锁的数量（1），最后得出结果c
2.判断当前线程是不是独占锁的线程，如果不是，抛出异常
3.如果c为0，表示锁被成功释放，把当前独占的线程设置为null,锁数量设置为0，返回true
4.如果c不为0，说明锁释放失败，锁数量设置为c,返回false
5.如果锁被释放成功的话，唤醒距离头结点最近的一个非取消的节点

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

调用的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;}

调用了tryRelease尝试释放锁

protected final boolean tryRelease(int releases) { int c = getState() - releases;//获取现在的锁数量-传入的解锁数量（这里为1）    if (Thread.currentThread() != getExclusiveOwnerThread())//当前线程不持有锁        throw new IllegalMonitorStateException();    boolean free = false;    if (c == 0) {//锁被释放        free = true;        setExclusiveOwnerThread(null);    }//如果不为0，怎么办，不释放了吗？    setState(c);    return free;}

尝试释放锁成功就唤醒等待队列中最近的一个节点，释放失败就把锁数量重置

private void unparkSuccessor(Node node) {        int ws = node.waitStatus;        if (ws < 0)//将ws设为0状态（即什么状态都不是）            compareAndSetWaitStatus(node, ws, 0);        /*         * 获取头节点的下一个等待状态不是cancel的节点         */        Node s = node.next;//头节点的下一个节点        if (s == null || s.waitStatus > 0) {            s = null;            /*             * 注意：从后往前遍历找到离头节点最近的一个非取消的节点，从后往前遍历据说是在入队（enq()）的时候，可能nodeX.next==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);//唤醒离头节点最近的一个非取消的节点    }

---