ReentrantLock源码解析

Java除了使用关键字synchronized，还可以用ReentrantLock实现独占锁的功能。ReentrantLock相比synchronized而言功能更加丰富，使用起来更为灵活，更多区别还需要大家自己去理解，只有充分了解了ReentrantLock和synchronized才会明白两者的区别所在，这里就不一一说明有哪些区别了，每个人的理解都不一样，死记硬背的逻辑不可靠。

ReentrantLock分为公平锁和非公平锁，用法如下：

package com.doaredo.test;

import org.junit.Test;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {

    @Test
    public void lock(){
        //公平锁
        ReentrantLock lock = new ReentrantLock(true);
        lock.lock();
        lock.unlock();

        //非公平锁
        ReentrantLock lock2 = new ReentrantLock(false);
        lock2.lock();
    }
}

加锁的过程就是让lock()方法正常返回，正常返回就表示拿锁成功。

逻辑图

首先我们要了解一些概念：CAS、AQS，CAS就是无锁并发操作，不明白的可以看看我前面写的CAS原理；再一个就是AQS，AQS它是一个队列，简单的说就是在并发情况下，没有拿到锁的线程就会进入到AQS排队等待。

我们了解到ReentrantLock使用的CAS无锁操作，既然是无锁操作，所以需要有个标志来表示锁，ReentrantLock中就是使用一个volatile修饰的int类型变量state来表示锁，0表示无锁、1表示拿到锁、大于1表示多次拿到锁(也就是常说的重入锁)。

除了对锁的状态进行处理外，ReentrantLock还依靠了AbstractQueuedSynchronizer(就是平时所说的AQS)来维护并发情况下，没有获取到锁的线程的排队。当并发情况下，线程没有获取到锁，就会进入AQS排队，ReentrantLock的公平锁与非公平锁的区别就在于AQS的排队；在使用公平锁时，所有没有拿到锁的线程都会依次排队，而在使用非公平锁时，进入排队的线程会尝试去获取锁，没有获取到锁才会去排队，如果在获取锁的过程中，锁正好被释放了，那么该线程就直接拿到锁了，而不用去排队，相对于正在排队的线程反而优先拿到了锁，所以叫做非公平锁。

对于在AQS队列中排队的线程，我们也需要知道它的状态，AQS中使用一个volatile修饰的int类型变量waitStatus来表示队列中线程的状态，这个waitStatus也不能说是状态，主要作用是判断队列中当前节点后面有没有排队的节点，当释放锁的时候，首先将锁状态state-1，然后waitStatus!=0的情况下才会去unpark唤醒后面的线程。默认新添加的节点waitStatus=0，当AQS队列中有新节点添加进来，就会将前一个节点的waitStatus修改为-1。这样如果节点的waitStatus = 0的话，表示后面没有节点了，也就没必要去unpark了，只需要把state-1就可以了。

根据上面所说的概念，尝试理解下面几张图，如果能够很好的理解这几张图，我相信对于ReentrantLock的源码就会不攻自破。

当只有一个线程使用锁时时

AQS

AQS中使用Node表示一个节点，每个节点都有prex指向上一节点，next指向下一节点。每个节点中都有一个Thread变量来存放线程。

初始情况下AQS中的head和tail都为null，当有线程要进行排队的时候就会进行初始化，初始化的时候先创建一个Thread为null的节点，而这个节点就是表示当前执行锁的线程节点。

接着创建排队线程的Node节点，指定Thread变量为排队线程，将prev指向初始化的Thread为null的节点，然后将tail(末端)指向将要入队的节点，然后将初始化的Thread为null的节点的next指向入队的节点。具体的入队过程如下图所示：

• 同时多个线程都要使用锁，只有一个线程可以拿到锁，其它的线程就要到AQS中去排队，等待锁的释放后，重新获取锁。这种情况是多个线程在同时获取锁的时候，AQS队列并没有被初始化过，也就是程序还没有碰到并发的情况，可以理解为程序第一次并发的情况。

• 当队列已经被初始化，这时候就不用考虑锁状态了，如果有线程在排队，那么就直接进入队列排队，如果只有Thread为null的一个节点，那么就尝试获取锁，获取锁失败的话，就会将前一节点的waitStatus改为-1，然后将自己加入AQS队列。前面说了waitStatus为-1时，表示后面有人排队。当持有锁的线程处理完，发现waitStatus为-1，则会去唤醒后面的节点线程。

• 当锁状态不为0时，表示锁被占用，于是将队列初始化，如果发现自己前面的节点为Thread为null的节点，表示前面是正在持有锁处理的节点，这时候会再次尝试CAS获取锁，如果获取失败，表明前一节点还没释放锁，这时候才真正进行park，等待前一节点释放锁后来唤醒。

  为什么要再次尝试CAS？因为前一节点正在处理，有可能这时候锁被释放了，所以尝试CAS一次，总的来说就是尽量让线程早点能够获取到锁。

• 锁释放的过程比较简单，就是将状态state-1，直到state为0，如果waitStatus!=0，则去唤醒下一节点。

照图看源码

搞清楚了上面这几个属性的意思，这样看源码就容易多了。具体大家参考源码中的注释，结合上面的图，慢慢来会很快。以下源码为公平锁：

package com.doaredo.test;

import org.junit.Test;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {

    @Test
    public void lock(){
        //公平锁
        ReentrantLock lock = new ReentrantLock(true);
        lock.lock();
        lock.unlock();

        //非公平锁
        ReentrantLock lock2 = new ReentrantLock(false);
        lock2.lock();
    }
}

/**
* Sync object for fair locks
* 公平锁
*/
static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1);
    }

    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
  	}
    /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        // 获取状态，0表示锁没有被占用
        if (c == 0) {
            // 虽然锁没有被占用，但是会存在多个线程同时来抢的情况，这时候就需要判断是否要排队
            if (!hasQueuedPredecessors() &&
                // 如果不用排队就将state+1，表示抢到了锁
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        // 如果获取锁的是仍是当前线程，也就是当前线程多次获取了锁(重入锁)
        else if (current == getExclusiveOwnerThread()) {
            // 重入锁就是将state再次+1
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
}

/**
* Acquires in exclusive mode, ignoring interrupts.  Implemented
* by invoking at least once {@link #tryAcquire},
* returning on success.  Otherwise the thread is queued, possibly
* repeatedly blocking and unblocking, invoking {@link
* #tryAcquire} until success.  This method can be used
* to implement method {@link Lock#lock}.
*
* @param arg the acquire argument.  This value is conveyed to
*        {@link #tryAcquire} but is otherwise uninterpreted and
*        can represent anything you like.
*/
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
    	acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    	selfInterrupt();
}

/**
* 
*/
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;
}
/*
* 这里是初始化队列以及入队操作
*/
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        // tail为空表示队列还没有初始化，创建一个Thread为空的Node节点
        // 注意这里是个死循环，如果没有初始化，第一次循环tail才为空
        if (t == null) { // Must initialize
          	if (compareAndSetHead(new Node()))
            		tail = head;
        } else {
            // 将当前线程的Node的prev指向上一个节点，也就是队列中的最后一个节点tail
            // 对应上图入队操作的第1步
            node.prev = t;
            // 将tail指向到当前线程的Node
            // 我百度了一些文章，有些说上面t == null的情况有两种，一种是没有初始化，另一种就是入队的时候tail还没有修改
            // 这里是使用的CAS操作，我认为tail为空的情况只有队列没有初始化这一种情况
            // 这里对应上图入队操作的第2步
            if (compareAndSetTail(t, node)) {
                // 将队列之前最后的节点的下一节点指向当前线程的节点
                // 也就是当前线程节点成了最后一个节点
                // 对应上图入队操作的第3步
                t.next = node;
                return t;
            }
        }
    }
}

/*
* 该方法对入队后的节点做一些后置处理
*/
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            // 获取节点的上一个节点
            final Node p = node.predecessor();
            // 如果上一个节点是head，会再次尝试一次CAS获取锁
            if (p == head && tryAcquire(arg)) {
                // CAS获取锁成功的话，将上一节点从队列中移除，将当前节点设置为head
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 查看上一个节点的waitStatus
            // 如果waitStatus>0，则会从队列中移除，直到入前找到waitStatus<=0的节点
            // 将往前找到的节点的waitStatus设置为-1
            if (shouldParkAfterFailedAcquire(p, node) &&
                // park当前线程
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    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 {
      /*
               * 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;
}

public final boolean release(int arg) {
    // 释放锁，也就是改变state的值
    if (tryRelease(arg)) {
        // 当state=0，才会进来
        Node h = head;
        // head表示的就是当前正在执行的线程，当state=0时，也就释放了锁
        // 如果正在执行的线程的waitStatus不等于0，表明后面还有节点，就有唤醒的必要
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}
/* 唤醒下一个节点的线程 */
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;
    // 下一节点为空或者waitStatus大于0
    // waitStatus大于0表示线程被取消的一些情况
    // 这时候就会一直往后找，直到找到waitStatus <=0 的节点
    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;
    }
    // 将找到的waitStatus <=0 的节点的线程进行unpark唤醒
    if (s != null)
      LockSupport.unpark(s.thread);
}

protected final boolean tryRelease(int releases) {
    // 将state-1
    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;
}