ReentrantLock源码探究1:非公平锁的获取和释放

AQS简单介绍

​ Sync是ReentrantLock的一个内部类，它继承了AbstractQueuedSynchronizer，即AQS，在CountDownLatch、FutureTask、Semaphore、ReentrantLock等源码中，我们都能看到它们的身影，足见其重要性。此处我们需要先了解下AQS才能更愉悦地阅读源码。

​ AQS中是基于FIFO队列的实现，那么它必然包含队列中元素的定义，在这里它是Node：

属 性	定 义
Node SHARED = new Node()	表示Node处于共享模式
Node EXCLUSIVE = null	表示Node处于独占模式
int CANCELLED = 1	因为超时或者中断，Node被设置为取消状态，被取消的Node不应该去竞争锁，只能保持取消状态不变，不能转换为其他状态，处于这种状态的Node会被踢出队列，被GC回收
int SIGNAL = -1	表示这个Node的继任Node被阻塞了，到时需要通知它
int CONDITION = -2	表示这个Node在条件队列中，因为等待某个条件而被阻塞
int PROPAGATE = -3	使用在共享模式头Node有可能处于这种状态， 表示锁的下一次获取可以无条件传播
int waitStatus	0，新Node会处于这种状态
Node prev	队列中某个Node的前驱Node
Node next	队列中某个Node的后继Node
Thread thread	这个Node持有的线程，表示等待锁的线程
Node nextWaiter	表示下一个等待condition的Node

AQS中包含的方法有

属性/方法	含 义
Thread exclusiveOwnerThread	这个是AQS父类AbstractOwnableSynchronizer的属性，表示独占模式同步器的当前拥有者
Node	上面已经介绍过了，FIFO队列的基本单位
Node head	FIFO队列中的头Node
Node tail	FIFO队列中的尾Node
int state	同步状态，0表示未锁
int getState()	获取同步状态
setState(int newState)	设置同步状态
boolean compareAndSetState(int expect, int update)	利用CAS进行State的设置
long spinForTimeoutThreshold = 1000L	线程自旋等待的时间
Node enq(final Node node)	插入一个Node到FIFO队列中
Node addWaiter(Node mode)	为当前线程和指定模式创建并扩充一个等待队列
void setHead(Node node)	设置队列的头Node
void unparkSuccessor(Node node)	如果存在的话，唤起Node持有的线程
void doReleaseShared()	共享模式下做释放锁的动作
void cancelAcquire(Node node)	取消正在进行的Node获取锁的尝试
boolean shouldParkAfterFailedAcquire(Node pred, Node node)	在尝试获取锁失败后是否应该禁用当前线程并等待
void selfInterrupt()	中断当前线程本身
boolean parkAndCheckInterrupt()	禁用当前线程进入等待状态并中断线程本身
boolean acquireQueued(final Node node, int arg)	队列中的线程获取锁
tryAcquire(int arg)	尝试获得锁（由AQS的子类实现它）
tryRelease(int arg)	尝试释放锁（由AQS的子类实现它）
isHeldExclusively()	是否独自持有锁
acquire(int arg)	获取锁
release(int arg)	释放锁
compareAndSetHead(Node update)	利用CAS设置头Node
compareAndSetTail(Node expect, Node update)	利用CAS设置尾Node
compareAndSetWaitStatus(Node node, int expect, int update)	利用CAS设置某个Node中的等待状态

另外在源码中多处使用了CAS，有关CAS的内容，可查看：

乐观锁的一种实现方式:CAS

非公平锁的获取过程

假设有两个线程：线程1和线程2尝试获取同一个锁（非公平锁），过程如下

1. 线程1调用lock方法

    final void lock() {
        if (compareAndSetState(0, 1))	//使用CAS将同步状态设置为1
            setExclusiveOwnerThread(Thread.currentThread());//成功则设置线程1为当前锁的独占线程
        else
            acquire(1);	//设置失败时，尝试获取锁
    }
//上述代码正常情况下执行完毕后，线程1成为了独占线程。

1. 线程2此时也尝试获取锁，调用lock方法，此时CAS设置时会失败，进入acquire方法。

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt(); //重新获取锁失败且线程发生了中断，自行中断
}

• 这里面，会首先调用tryAcquire方法尝试再次获取锁，因为我们演示的是非公平锁，因此调用的方法是nonfairTryAcquire。

    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();	//current指向当前线程2
        int c = getState();		 //若线程1未释放锁，则c>0，若线程1已经释放锁，则c=0
        if (c == 0) {			 //线程1已经释放了锁
            if (compareAndSetState(0, acquires)) {	//使用CAS将state设置为1
                setExclusiveOwnerThread(current);	//并设置线程2为独占线程
                return true;	//返回true，获取锁成功
            }
        }
        //判断该线程是否是重入，即之前已经获取到了锁
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires; //每重入一次，将state+1。
            if (nextc < 0) // overflow //state+1<0，说明原state为负数，抛出异常
                throw new Error("Maximum lock count exceeded");
            setState(nextc);	//设置state为新值
            return true;		//返回true，获取重入锁成功。
        }
        return false;			//返回flase，获取锁失败
    }

• 此时线程2使用tryAcquire方法获取锁，如果也是失败，那么，会调用addWaiter(Node.EXCLUSIVE)方法

private Node addWaiter(Node mode) {  //此处mode为独占模式
    Node node = new Node(Thread.currentThread(), mode);//将当前线程(此处为线程2)绑定到新节点node上，并设置为独占模式
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;	//获取原队列的尾节点pred
    if (pred != null) {	//若原尾节点pred非空，则说明已经存在一个队列
        node.prev = pred;	//设置新节点node的前置为pred
        if (compareAndSetTail(pred, node)) {//使用CAS设置新的尾节点为node
            pred.next = node;	//设置pred的后置为node，建立双向链接
            return node;		//返回node
        }
    }
    enq(node);		//进入此处说明原队列不存在，需要初始化队列
    return node;
}

private Node enq(final Node node) { //此处传入的参数node是绑定了线程2的节点
    for (;;) {
        Node t = tail;		//获取原队列的尾节点t
        if (t == null) { // Must initialize //若尾节点为空，说明队列尚未形成
            if (compareAndSetHead(new Node())) //设置一个空的，未绑定任何线程的节点为新队列的头节点
                tail = head;	//新队列只有一个节点，既是头也是尾
        } else {		//若t非空，说明队列已经形成
            node.prev = t;  //将node的前置设为t
            if (compareAndSetTail(t, node)) { //CAS设置新的尾节点为node
                t.next = node;	//设置t的后继为node，建立双向链接
                return t;		//返回t
            }
        }
    }
}

• 现在看外层方法acquireQueued，此时传入的参数node是线程2所在节点，该方法的作用是在等待队列中，当有其他线程释放了资源，那么队列中在等待的线程就可以开始行动

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true; //是否获取到资源
    try {
        boolean interrupted = false; //等待过程中是否被中断
        //自旋，维护等待队列中线程的执行。
        for (;;) {
            final Node p = node.predecessor(); //获取node的前置p
            if (p == head && tryAcquire(arg)) { //若前置p为头结点并且重新获取锁成功
                setHead(node);					//设置新的头节点为node
                p.next = null; // help GC		//取消p和链表的链接
                failed = false;					//获取资源未失败
                return interrupted;				//等待过程未被中断
            }
            if (shouldParkAfterFailedAcquire(p, node) &&  //若前置节点是Node.SIGNAL状态
                parkAndCheckInterrupt())		//将节点设置为Waitting状态
                interrupted = true;   //此时线程中断状态为true
        }
    } finally {
        if (failed)                   //如果获取资源成功那么取消获取过程
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;	 //获取前置节点的等待状态
        if (ws == Node.SIGNAL)		//Node.SIGNAL表示继任者线程需要被唤醒，那么就可以直接返回；
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {		//若ws>0，说明前驱被取消，那么执行循环往前一直查找，知道找到未被取消的，将node排在它的后面。
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {   //进入else，说明ws=0或者Node.PROPAGATE
            /*
             * 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.
             */
            //使用CAS设置前置的节点状态为Node.SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

该部分代码可以用现实中排队办理业务的情况来说明：

假设你排队去办理业务，队伍很长，因此除了当前正在办理业务的人，其他所有排队的人都在低头玩手机，且每个排队的人有以下三种状态：①.正常排队，且办完业务后会通知后面的人别玩手机了可以开始办理业务了。②.发现队伍过长，不排队了，走了。③.正常排队，办完业务后不通知后面的人，直接走。
   此时你进入该队伍的尾部开始排队。
1.第一步，判断排队在你前面的人是否会通知你，如果会通知，那么我们就可以不用关心其他问题，在队列中待着玩手机即可。
2.第二步，如果发现排在你前面的人不排队了，要走了，那么此时我们就得往前走一位，并开始不断询问前面的人是不是也准备不排队了，直到我们排在了一个确定不会走的人后面。
3.第三步，排在你前面的人不是准备走的，但是他也不会通知你，那么你就要告诉他，一定得在办完业务后通知你。

当我们确定我们已经在队列中待好后(前置会通知我们)，那么我们就可以开始休息。parkAndCheckInterrupt方法让我们的线程进入等待的状态，即休息状态。

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);  //调用park()使线程进入waiting状态
    return Thread.interrupted(); //如果被唤醒，查看自己是不是被中断的。
}

锁的释放过程

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

public final boolean release(int arg) {
    if (tryRelease(arg)) {	//若tryRelease后无人占用锁
        Node h = head;		//获取队列的头结点h
        if (h != null && h.waitStatus != 0)	//若h非空，且h的waitStatus不为0
            unparkSuccessor(h);		//唤醒后继
        return true;
    }
    return false;
}

    protected final boolean tryRelease(int releases) {
        int c = getState() - releases;	//当前state-1，得到c
        if (Thread.currentThread() != getExclusiveOwnerThread()) //执行releas的不是获取锁的独占线程，抛出异常
            throw new IllegalMonitorStateException();
        boolean free = false;	//free用来标记锁是否可获取状态
        if (c == 0) {			//若state=0
            free = true;		//那么当前锁是可获取的
            setExclusiveOwnerThread(null);	//设置当前锁的独占线程为null
        }
        setState(c);			//设置当前state为c
        return free;			//返回锁是否是可获取状态
    }

 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; //获取当前线程对应节点的waitStatus
        if (ws < 0)				 //将当前线程对应节点waitStatus置为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;		//获取当前线程对应节点的后继节点s
        if (s == null || s.waitStatus > 0) { //若s为空或s的状态是canceled
            s = null;                        //将s设置为null。
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)  //此处从尾到头进行遍历，找到队列最前列的节点且状态不是Canceled，将其设置为s。但此处为何从尾部开始遍历尚未弄清楚。
                    s = t;
        }
        if (s != null)		//若上述遍历找到的s非空
            LockSupport.unpark(s.thread);  //调用lockSupport.unpark唤醒s对应的线程
    }

release方法的逻辑仍然可以用一个办理完业务的人的后续动作来进行说明：

1.若A办理业务后无其他业务需要办理，那么表示当前业务窗口是free的。
2.A将自己的等待状态置为0，相当于退出队列。然后检查自己后面的人是否是空或者取消排队的状态。若为真，将后置设为空。
3.从队列的尾部遍历到头部，直到找到队列最前头的那个，且它的等待状态不是取消状态，那么将其唤醒，告知他可以开始办理业务了。

关于源码的一点疑问

本文中部分源码本人暂时也尚未能理解，希望各位大佬不吝赐教，主要有以下一些问题：

1.在unparkSuccessor方法中，找到队列下一个节点并将其唤醒时，为什么从尾到头遍历

        if (s == null || s.waitStatus > 0) { //若s为空或s的状态是canceled
            s = null;                        //将s设置为null。
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)    //倒序遍历？
                    s = t;
        }

2.在acquireQueued方法中，自旋结束后的finally代码块的作用。

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true; //是否获取到资源
    try {
        boolean interrupted = false; //等待过程中是否被中断
        //自旋，维护等待队列中线程的执行。
        for (;;) {
            final Node p = node.predecessor(); //获取node的前置p
            if (p == head && tryAcquire(arg)) { //若前置p为头结点并且重新获取锁成功
                setHead(node);					//设置新的头节点为node
                p.next = null; // help GC		//取消p和链表的链接
                failed = false;					//获取资源未失败
                return interrupted;				//等待过程未被中断
            }
            if (shouldParkAfterFailedAcquire(p, node) &&  //若前置节点是Node.SIGNAL状态
                parkAndCheckInterrupt())		//将节点设置为Waitting状态
                interrupted = true;   //此时线程中断状态为true
        }
    } finally {
        if (failed)                       //如果自旋结束，那么说明failed = false已经执行了，那么这个canclAcquire方法什么情况下会执行？
            cancelAcquire(node);
    }
}