ReentrantLock源码解析

1. 基本概念

ReentrantLock是一种排他锁，拥有synchronized的功能但是又比synchronized强大。ReentrantLock可以以公平或者非公平的方式去获取锁，默认采用非公平的方式去获取锁。本文主要讲解默认方式(非公平的去获取锁)

2. 继承关系

ReentrantLock实现了Lock和Serializable，所以ReentrantLock需要实现Lock的所有方法。

public interface Lock {
    /**
     * 获取锁，如果成功获取就马上返回，否着阻塞
     */
    void lock();

    /**
     * 获取锁，如果成功获取就马上返回，否着阻塞直到线程发生中断，如果发生中断请求就抛出InterruptedException
     */
    void lockInterruptibly() throws InterruptedException;

    /**
     * 尝试着去获取锁，如果成功就立刻返回true否则立刻返回false,不会阻塞
     */
    boolean tryLock();

    /**
     * 在一定的事件内去获取锁，如果获取成功，就返回true,否则返回false,如果在尝试获取锁的过程中发生了中断，就抛出InterruptedException
    */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
     * 释放锁
     */
    void unlock();

    /**
     *返回锁的Condition实例
     */
    Condition newCondition();
}

ReentrantLock里面还有一个静态的Sync继承了AbstractQueuedSynchronizer(AQS)，实现了对锁的内部机制的封装。为了实现公平锁和非公平锁，又有NonfairSync和FairSync两个静态类继承Sync。AQS时ReentrantLock的主要实现原理，ReentrantLock中的方法都会最终调用AQS的方法。AQS时Java多线程中很重要的一个类，很多类都是基于AQS实现的，比如说CountDownLatch,Semaphore,ReentrantLock,ReentrantReadWriteLock等等。

如果需要使用AQS，就需要实现它的以下几个方法，不需要全部实现，只需要实现你要用的那几个：

• tryAcquire

• tryRelease

• tryAcquireShared

• tryReleaseShared

• isHeldExclusively

ReentrantLock中的Sync类只实现了tryAcquire,tryRelease,isHeldExclusively方法。

3. 核心源码解析

1) ReentrantLock的lock方法解析

当调用ReentrantLock的lock方法时，会调用Sync的lock方法

//Sync
final void lock() {
    if (compareAndSetState(0, 1))// 将AQS中的state设置成1，主要0表示当前没有线程获取锁
        setExclusiveOwnerThread(Thread.currentThread()); // 将当前线程设置成拥有这个锁的线程
    else
        acquire(1);
}

acquire方法时AQS的核心方法， 采用模板设计模式。

// AQS
// 尝试去获取锁，如果获取失败就把线程放入链表中
// tryAcquire去尝试获取锁， 如果获取失败，就调用acquireQueued将当前想获取锁的线程放进链表中
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

使用非公平的方式去获取锁.

如果当前的锁没有被获取，就尝试获取锁，如果获取成功就返回true

如果当前的锁已经被获取了并且获取了的线程时当前线程，就更新state然后返回true

否则当前线程无法获取锁，返回false

// NonfairSync
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
// Sync
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();//获取当前线程
    int c = getState();//获取state变量的值
    if (c == 0) {// 0 代表没有线程获取锁
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) { //检查已经获取到锁的线程是否时当前线程。如果是，更新state
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

AQS中维护着链表的head和tail。初始状态下都是null。

addWaiter将等待的线程加入链表中。

//AQS
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    if (pred != null) { //tail不是null, 代表链表已经初始化过了，将node添加到链表的末尾。
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //如果tail是null，说明链表还没有被初始化，使用enq方法进行初始化，并将node添加到链表中
    enq(node);
    return node;
}

//初始化链表并将node添加到链表中
//new一个Node作为head和tail，容后将node添加到tail的后面
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;
            }
        }
    }
}

acquireQueued是很重要的方法。

当node是最链表中的第二个节点(最应该获取锁的节点)，就尝试获取锁，

如果获取失败或者node不是第二个节点(更靠后的节点)，就用shouldParkAfterFailedAcquire检查是否应该park，如果需要park，就直接LockSupport.park(this)，暂停这个线程。

如果线程在暂停状态，当调用lock的release方法去调用LockSupport.unpark(this)来启动这个线程。当线程再次启动之后，会检查这个线程是否被中断。

如果获取失败，就检查是否应该park，如果应该park就调用
//AQS
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;//表示线程有没有被中断
        for (;;) {
            final Node p = node.predecessor();//获取node节点的前一个节点
            if (p == head && tryAcquire(arg)) {//如果p是head节点，说明当前线程是链表最前面的线程，然后尝试获取锁
                setHead(node);//获取锁成功后，将node设置成head，然后直接返回
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&//检查是否应该park
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

 

// Node
static final class Node{
    static final int CANCELLED =  1;
    static final int SIGNAL    = -1;
    static final int CONDITION = -2;
    static final int PROPAGATE = -3;
}

//AQS
//如果pred的waitSatatus是Node.SIGNAL，就返回true
//如果pred没有被中断，就设置为pred的waitStatus为Node.SIGNAL，并返回false
//如果pred被中断了，就从链表中清除这个节点，并返回false
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;
}

//调用LockSupport.park,暂停当前线程
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

2) ReentrantLock的unlock方法解析

当调用ReentrantLock的unlock方法时，会调用Sync的release方法

//Sync
//尝试release这个锁，如果release成功，就从链表中取出下一个节点并启动
//如果release失败(state比0大，锁还没有完全释放)，就直接返回false
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);//  启动这个线程        return true;
    }
    return false;
}

释放锁，并更新state的状态

如果在释放之后，没有任何锁了，就返回true

//如果在释放之后，还有锁存在，就放回false
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;
}

//寻找需要启动的线程，并将其启动
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表明链表中没有其他的线程在等待锁，s.waitStatus > 0表明线程s已经被取消了，从队列的尾部查找是否有需要启动的线程        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);
}