ReentrantLock源码分析

一、AQS

AQS全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架

1、state属性

• 用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁

  • getState ： 获取 state 状态
  • setState ： 设置 state 状态
  • compareAndSetState ： cas 机制设置 state 状态
  • 独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源

• state 使用 volatile 配合 cas 保证其修改时的原子性

2、等待队列

• 提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList
• 设计时借鉴了 CLH 队列，它是一种单向无锁队列

3、条件变量

• 条件变量来实现等待、唤醒机制，支持多个条件变量，类似于 Monitor 的 WaitSet

二、ReentrantLock

1、非公平锁实现原理

1.1 获取锁

1、ReentrantLock默认为非公平锁实现，NonfairSync 继承自 AQS

public ReentrantLock() {
   sync = new NonfairSync();
}

2、执行lock方法加锁，这里使用的是非公平锁的lock方法

public void lock() {
    sync.lock();
}

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     */
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

通过CAS的方式尝试将state从0修改为1

• 如果修改成功，就将锁的拥有者设置为当前线程

  

• 如果修改失败，执行acquire(1)方法。在acquire方法中，通过tryAcquire方法尝试再获取一次锁，如果获取成功，就退出当前方法

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

// 上边NonfairSync类的tryAcquire方法
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

final boolean nonfairTryAcquire(int acquires) {
    // 拿到当前线程
    final Thread current = Thread.currentThread();
    // 获取state状态
    int c = getState();
    // 如果state状态为0，表示锁空闲，可以尝试获取锁
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 如果锁不是空闲的，判断锁的拥有者是否是当前线程
    else if (current == getExclusiveOwnerThread()) {
        // 是的话，就将当前锁的重入次数+1，然后修改state的状态为锁重入次数，返回true
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    // 获取锁失败
    return false;
}

• acquire方法获取锁失败，会继续执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法

private Node addWaiter(Node mode) {
    // 为当前线程创建一个Node
    Node node = new Node(Thread.currentThread(), mode);
    // 拿到队列尾结点
    Node pred = tail;
    // 如果尾结点不为空，将当前节点的上一个节点设置为尾结点，同时通过cas的方式将当前节点设置为尾结点，然后返回当前节点
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 如果尾结点为空表示当前队列为空，执行enq方法
    enq(node);
    return node;
}

private Node enq(final Node node) {
    for (;;) {
        // 拿到尾结点
        Node t = tail;
        // 如果尾结点为空，就创建一个空节点作为头结点，并且尾结点也指向该节点，然后继续循环
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        // 下次循环时，尾结点就不为空，将当前节点的前驱设置为t，然后通过cas的方式将当前节点设置为尾结点，并返回
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

// 这里的node就是通过addWaiter()方法返回的节点，此时arg是1
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            // 拿到当前节点的前驱节点p
            final Node p = node.predecessor();
            // 如果p为头结点，表示当前节点是队列中第一个节点，那么就再次尝试获取锁，如果获取锁成功，就将当前节点设置为头结点，将p节点从队列中断开
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 如果p不是头结点，或者获取锁失败
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取前驱节点的状态，默认是0
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL) // 如果ws==-1，就返回true，-1表示节点正在阻塞，他可以将下一个节点唤醒，既然前驱都阻塞了，那么返回true，当前节点也阻塞
        return true;
    if (ws > 0) { // 如果ws>0，表示取消状态，就一直往前找，删除前边所有取消的节点，直到找到ws<=0的节点，然后将该节点的后继设置为node
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else { // 如果ws==0，表示前驱节点还没有阻塞，通过cas的方式将ws设置为-1
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

// 如果shouldParkAfterFailedAcquire方法返回true表示node节点可以被上一个节点唤醒，那么执行parkAndCheckInterrupt方法，通过part暂停node节点的线程
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

1.2 释放锁

1、释放锁调用的是sync的release(1)方法

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

public final boolean release(int arg) {
    // 如果tryRelease方法返回true，表示释放锁后，锁空闲
    if (tryRelease(arg)) {
        // 拿到head节点，如果head不为空，并且头节点状态不为0，那么就唤醒头结点的下一个节点
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    // 锁重入次数-1，锁还是被占有的，返回false
    return false;
}

protected final boolean tryRelease(int releases) {
    // getState是获取state状态，如果锁是重入的，那么state>1，c就是当前线程释放一次锁时，state状态
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 如果c==0，表示当前线程释放锁后，锁空闲，就将锁的拥有者设置为null，并返回true
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 如果c!=0，表示锁重入次数-1，返回false
    setState(c);
    return free;
}

private void unparkSuccessor(Node node) {
    // 拿到当前头结点的状态
    int ws = node.waitStatus;
    if (ws < 0) // 如果ws<0，那么将状态设置为0
        compareAndSetWaitStatus(node, ws, 0);

    // 拿到头结点的下一个节点
    Node s = node.next;
    // 如果下一个需要唤醒的节点为空，或者状态>0，那么就从队尾向队头遍历，找到最前边一个状态<=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;
    }
    // 通过unpark将下一个节点唤醒
    if (s != null)
        LockSupport.unpark(s.thread);
}

2、唤醒的线程尝试获取锁

• 当前线程开始时通过park被暂停的，现在通过unpark被唤醒，那么当前线程的节点就是头结点后的第一个节点，会循环再次通过tryAcquire(arg)去尝试获取锁，如果获取锁成功，就将头结点断开，将当前节点设置为头结点。
• 如果此时新来一个线程，他抢到了锁，当前被唤醒的线程获取锁失败，他会再次被park暂停

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;
                // 返回中断标记 false
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

1.3 可重入原理

static final class NonfairSync extends Sync {
    // ...
    
    // Sync 继承过来的方法
    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()) {
            // state++
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
    
    // Sync 继承过来的方法
    protected final boolean tryRelease(int releases) {
        // state-- 
        int c = getState() - releases;
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        // 支持锁重入, 只有 state 减为 0, 才释放成功
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }
}

1.4 可打断原理

不可打断

不可打断是指当前线程被打断了，但是他还需要去获取锁，如果获取锁失败，继续park，获取锁成功就返回true，然后将当前线程打断标记设为true

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;
            }
            // 如果当前线程可以被暂停，那么就执行parkAndCheckInterrupt方法，调用park将当前线程暂停
            // 如果当前线程被打断了，那么会执行interrupted = true，然后该线程会继续去尝试获取锁，如果获取锁失败，继续park，如果获取锁成功，就返回true
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    // 如果当前线程被打断，那么Thread.interrupted()会返回true，同时会清除打断标记
    // 因为如果打断标记为true，park会失效，这里清除打断标记是为了使当前线程可以再次被park
    return Thread.interrupted();
}

public final void acquire(int arg) {
    // 这里调用的acquireQueued方法，如果返回true，表示当前线程获取锁成功，但是当前线程是被打断的，并且打断标记已经清除，因此需要执行selfInterrupt()
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

// 将当前线程打断标记重新设置为true
static void selfInterrupt() {
    Thread.currentThread().interrupt();
}

可打断

lockInterruptibly方法获取锁是可以被打断的，当线程在AQS队列等待时被打断，会直接抛出异常，然后退出

public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

public final void acquireInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    // 当前线程如果获取锁失败，就执行doAcquireInterruptibly方法
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}

private void doAcquireInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return;
            }
            // 如果当前线程可以被暂停，那么就执行parkAndCheckInterrupt方法，调用park将当前线程暂停
            // 如果当前线程被打断了，就直接抛出异常，然后退出
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

1.5 公平锁实现原理

当前线程尝试获取锁时，会先判断AQS队列中是否有线程，如果有，就获取锁失败，否则才去获取锁

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

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

// FairSync类中的tryAcquire实现
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 如果锁是空闲的，同时AQS队列中没有线程节点，那么当前线程尝试获取锁
        if (!hasQueuedPredecessors() &&
            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;
    }
    // 锁空闲，但是AQS队列有线程  或者 锁被占用，都会返回false
    return false;
}

public final boolean hasQueuedPredecessors() {
    // The correctness of this depends on head being initialized
    // before tail and on head.next being accurate if the current
    // thread is first in queue.
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    // 如果头结点和尾结点不相同，并且头结点的下一个节点为空，或者当前线程和队列中第一个线程不是同一个线程，就返回true
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

1.6 条件变量原理

await

每个条件变量就对应着一个等待队列，其实现类是 ConditionObject

调用condition.await()方法

• 调用addConditionWaiter将当前线程创建一个节点，加入到条件变量的等待队列中
• 通过fullyRelease方法释放锁，唤醒AQS队列中第一个线程
• 当前线程被park阻塞
• 如果线程退出等待队列后，会再次会去竞争锁

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    // 调用addConditionWaiter方法创建一个Node节点，将该节点放到条件变量队列尾部，返回该节点
    Node node = addConditionWaiter();
    // fullyRelease方法，拿到当前锁的state状态，fullyRelease是因为当前线程可能会重入锁，所以要全部释放
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    // 如果该节点还没有转移至 AQS 队列, 阻塞
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        // 如果被打断, 退出等待队列
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    // 退出等待队列后, 该节点尝试获得锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    // 所有已取消的 Node 从队列链表删除
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

private Node addConditionWaiter() {
    // 拿到条件变量队列中的尾结点
    Node t = lastWaiter;
    // 如果不为空，并且他的状态不是-2，就将队列中已经取消的节点删除
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    // 为当前线程创建一个Node节点，状态为-2，表示等待
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    // 如果当前队列为空，就将当前node设为头结点，否则将node放到队列尾部
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

final int fullyRelease(Node node) {
    boolean failed = true;
    try {
        // 拿到锁的状态
        int savedState = getState();
        // 如果释放锁成功，failed置位false，同时返回锁的状态
        if (release(savedState)) {
            failed = false;
            return savedState;
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        // 如果释放锁失败，将当前线程的waitStatus设为1，表示取消
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}

public final boolean release(int arg) {
    // 释放锁，将锁的拥有者设为null，并将锁的状态设为0
    if (tryRelease(arg)) {
        Node h = head;
        // 唤醒AQS队列中第一个线程
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

signal

1、拿到条件变量等待队列中第一个节点，执行doSignal方法唤醒该节点

2、将该节点从等待队列断开，并加入AQS队列尾部进行等待，如果成功就直接退出，如果失败就循环唤醒下一个节点

3、将AQS队列中原来的尾结点状态修改为-1，当前节点作为尾结点，状态为0

public final void signal() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    // 拿到条件变量的等待队列中第一个节点
    Node first = firstWaiter;
    // 唤醒first线程
    if (first != null)
        doSignal(first);
}

private void doSignal(Node first) {
    do {
        // 如果first节点的下一个节点为空，表示当前线程被唤醒后，等待队列为空，就将尾结点置空
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        // 将first节点从队列中断开
        first.nextWaiter = null;
    } while (!transferForSignal(first) &&
             (first = firstWaiter) != null);
}

final boolean transferForSignal(Node node) {
    // 将当前节点通过cas方式将状态从-2修改为0，如果修改失败，返回false
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;

    // 将当前节点加入AQS队列尾部，同时返回他的上一个节点，即原来的尾结点
    Node p = enq(node);
    // 拿到p的状态
    int ws = p.waitStatus;
    // 如果p的状态大于0，或者将状态修改为-1失败，就将当前线程唤醒
    // 否则，将p的状态修改为-1，用来唤醒当前节点
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}