死磕 java同步系列之ReentrantLock源码解析（一）——公平锁、非公平锁

// 获取锁void lock();// 获取锁（可中断）void lockInterruptibly() throws InterruptedException;// 尝试获取锁，如果没获取到锁，就返回falseboolean tryLock();// 尝试获取锁，如果没获取到锁，就等待一段时间，这段时间内还没获取到锁就返回falseboolean tryLock(long time, TimeUnit unit) throws InterruptedException;// 释放锁void unlock();// 条件锁Condition newCondition();

abstract static class Sync extends AbstractQueuedSynchronizer {}
static final class NonfairSync extends Sync {}
static final class FairSync extends Sync {}

private final Sync sync;

// 默认构造方法public ReentrantLock() {    sync = new NonfairSync();}// 自己可选择使用公平锁还是非公平锁public ReentrantLock(boolean fair) {    sync = fair ? new FairSync() : new NonfairSync();}

ReentrantLock reentrantLock = new ReentrantLock(true);

/*
* 提示：该行代码过长，系统自动注释不进行高亮。一键复制会移除系统注释 
* // ReentrantLock.lock()public void lock() {    // 调用的sync属性的lock()方法    // 这里的sync是公平锁，所以是FairSync的实例    sync.lock();}// ReentrantLock.FairSync.lock()final void lock() {    // 调用AQS的acquire()方法获取锁    // 注意，这里传的值为1    acquire(1);}// AbstractQueuedSynchronizer.acquire()public final void acquire(int arg) {    // 尝试获取锁    // 如果失败了，就排队    if (!tryAcquire(arg) &&        // 注意addWaiter()这里传入的节点模式为独占模式        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))        selfInterrupt();}// ReentrantLock.FairSync.tryAcquire()protected final boolean tryAcquire(int acquires) {    // 当前线程    final Thread current = Thread.currentThread();    // 查看当前状态变量的值    int c = getState();    // 如果状态变量的值为0，说明暂时还没有人占有锁    if (c == 0) {        // 如果没有其它线程在排队，那么当前线程尝试更新state的值为1        // 如果成功了，则说明当前线程获取了锁        if (!hasQueuedPredecessors() &&            compareAndSetState(0, acquires)) {            // 当前线程获取了锁，把自己设置到exclusiveOwnerThread变量中            // exclusiveOwnerThread是AQS的父类AbstractOwnableSynchronizer中提供的变量            setExclusiveOwnerThread(current);            // 返回true说明成功获取了锁            return true;        }    }    // 如果当前线程本身就占有着锁，现在又尝试获取锁    // 那么，直接让它获取锁并返回true    else if (current == getExclusiveOwnerThread()) {        // 状态变量state的值加1        int nextc = c + acquires;        // 如果溢出了，则报错        if (nextc < 0)            throw new Error("Maximum lock count exceeded");        // 设置到state中        // 这里不需要CAS更新state        // 因为当前线程占有着锁，其它线程只会CAS把state从0更新成1，是不会成功的        // 所以不存在竞争，自然不需要使用CAS来更新        setState(nextc);        // 当线程获取锁成功        return true;    }    // 当前线程尝试获取锁失败    return false;}// AbstractQueuedSynchronizer.addWaiter()// 调用这个方法，说明上面尝试获取锁失败了private Node addWaiter(Node mode) {    // 新建一个节点    Node node = new Node(Thread.currentThread(), mode);    // 这里先尝试把新节点加到尾节点后面    // 如果成功了就返回新节点    // 如果没成功再调用enq()方法不断尝试    Node pred = tail;    // 如果尾节点不为空    if (pred != null) {        // 设置新节点的前置节点为现在的尾节点        node.prev = pred;        // CAS更新尾节点为新节点        if (compareAndSetTail(pred, node)) {            // 如果成功了，把旧尾节点的下一个节点指向新节点            pred.next = node;            // 并返回新节点            return node;        }    }    // 如果上面尝试入队新节点没成功，调用enq()处理    enq(node);    return node;}// AbstractQueuedSynchronizer.enq()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;            // CAS更新尾节点为新节点            if (compareAndSetTail(t, node)) {                // 成功了，则设置旧尾节点的下一个节点为新节点                t.next = node;                // 并返回旧尾节点                return t;            }        }    }}// AbstractQueuedSynchronizer.acquireQueued()// 调用上面的addWaiter()方法使得新节点已经成功入队了// 这个方法是尝试让当前节点来获取锁的final boolean acquireQueued(final Node node, int arg) {    // 失败标记    boolean failed = true;    try {        // 中断标记        boolean interrupted = false;        // 自旋        for (;;) {            // 当前节点的前一个节点            final Node p = node.predecessor();            // 如果当前节点的前一个节点为head节点，则说明轮到自己获取锁了            // 调用ReentrantLock.FairSync.tryAcquire()方法再次尝试获取锁            if (p == head && tryAcquire(arg)) {                // 尝试获取锁成功                // 这里同时只会有一个线程在执行，所以不需要用CAS更新                // 把当前节点设置为新的头节点                setHead(node);                // 并把上一个节点从链表中删除                p.next = null; // help GC                // 未失败                failed = false;                return interrupted;            }            // 是否需要阻塞            if (shouldParkAfterFailedAcquire(p, node) &&                // 真正阻塞的方法                parkAndCheckInterrupt())                // 如果中断了                interrupted = true;        }    } finally {        // 如果失败了        if (failed)            // 取消获取锁            cancelAcquire(node);    }}// AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire()// 这个方法是在上面的for()循环里面调用的// 第一次调用会把前一个节点的等待状态设置为SIGNAL，并返回false// 第二次调用才会返回trueprivate static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {    // 上一个节点的等待状态    // 注意Node的waitStatus字段我们在上面创建Node的时候并没有指定    // 也就是说使用的是默认值0    // 这里把各种等待状态再贴出来    //static final int CANCELLED =  1;    //static final int SIGNAL    = -1;    //static final int CONDITION = -2;    //static final int PROPAGATE = -3;    int ws = pred.waitStatus;    // 如果等待状态为SIGNAL(等待唤醒)，直接返回true    if (ws == Node.SIGNAL)        return true;    // 如果前一个节点的状态大于0，也就是已取消状态    if (ws > 0) {        // 把前面所有取消状态的节点都从链表中删除        do {            node.prev = pred = pred.prev;        } while (pred.waitStatus > 0);        pred.next = node;    } else {        // 如果前一个节点的状态小于等于0，则把其状态设置为等待唤醒        // 这里可以简单地理解为把初始状态0设置为SIGNAL        // CONDITION是条件锁的时候使用的        // PROPAGATE是共享锁使用的        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);    }    return false;}// AbstractQueuedSynchronizer.parkAndCheckInterrupt()private final boolean parkAndCheckInterrupt() {    // 阻塞当前线程    // 底层调用的是Unsafe的park()方法    LockSupport.park(this);    // 返回是否已中断    return Thread.interrupted();}
*/

ReentrantLock#lock()->ReentrantLock.FairSync#lock() // 公平模式获取锁  ->AbstractQueuedSynchronizer#acquire() // AQS的获取锁方法    ->ReentrantLock.FairSync#tryAcquire() // 尝试获取锁    ->AbstractQueuedSynchronizer#addWaiter()  // 添加到队列      ->AbstractQueuedSynchronizer#enq()  // 入队    ->AbstractQueuedSynchronizer#acquireQueued() // 里面有个for()循环，唤醒后再次尝试获取锁      ->AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire() // 检查是否要阻塞      ->AbstractQueuedSynchronizer#parkAndCheckInterrupt()  // 真正阻塞的地方

// ReentrantLock.lock()public void lock() {    sync.lock();}// ReentrantLock.NonfairSync.lock()// 这个方法在公平锁模式下是直接调用的acquire(1);final void lock() {    // 直接尝试CAS更新状态变量    if (compareAndSetState(0, 1))        // 如果更新成功，说明获取到锁，把当前线程设为独占线程        setExclusiveOwnerThread(Thread.currentThread());    else        acquire(1);}// ReentrantLock.NonfairSync.tryAcquire()protected final boolean tryAcquire(int acquires) {    // 调用父类的方法    return nonfairTryAcquire(acquires);}// ReentrantLock.Sync.nonfairTryAcquire()final boolean nonfairTryAcquire(int acquires) {    final Thread current = Thread.currentThread();    int c = getState();    if (c == 0) {        // 如果状态变量的值为0，再次尝试CAS更新状态变量的值        // 相对于公平锁模式少了!hasQueuedPredecessors()条件        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;}

lock.lock();
if (Thread.currentThread().interrupted()) {    return ;}
lock.unlock();

// ReentrantLock.tryLock()public boolean tryLock() {    // 直接调用Sync的nonfairTryAcquire()方法    return sync.nonfairTryAcquire(1);}// ReentrantLock.Sync.nonfairTryAcquire()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;}

// ReentrantLock.tryLock()public boolean tryLock(long timeout, TimeUnit unit)        throws InterruptedException {    // 调用AQS中的方法    return sync.tryAcquireNanos(1, unit.toNanos(timeout));}// AbstractQueuedSynchronizer.tryAcquireNanos()public final boolean tryAcquireNanos(int arg, long nanosTimeout)        throws InterruptedException {    // 如果线程中断了，抛出异常    if (Thread.interrupted())        throw new InterruptedException();    // 先尝试获取一次锁    return tryAcquire(arg) ||        doAcquireNanos(arg, nanosTimeout);}// AbstractQueuedSynchronizer.doAcquireNanos()private boolean doAcquireNanos(int arg, long nanosTimeout)        throws InterruptedException {    // 如果时间已经到期了，直接返回false    if (nanosTimeout <= 0L)        return false;    // 到期时间    final long deadline = System.nanoTime() + nanosTimeout;    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 true;            }            nanosTimeout = deadline - System.nanoTime();            // 如果到期了，就直接返回false            if (nanosTimeout <= 0L)                return false;            // spinForTimeoutThreshold = 1000L;            // 只有到期时间大于1000纳秒，才阻塞            // 小于等于1000纳秒，直接自旋解决就得了            if (shouldParkAfterFailedAcquire(p, node) &&                nanosTimeout > spinForTimeoutThreshold)                // 阻塞一段时间                LockSupport.parkNanos(this, nanosTimeout);            if (Thread.interrupted())                throw new InterruptedException();        }    } finally {        if (failed)            cancelAcquire(node);    }}

// java.util.concurrent.locks.ReentrantLock.unlock()public void unlock() {    sync.release(1);}// java.util.concurrent.locks.AbstractQueuedSynchronizer.releasepublic final boolean release(int arg) {    // 调用AQS实现类的tryRelease()方法释放锁    if (tryRelease(arg)) {        Node h = head;        // 如果头节点不为空，且等待状态不是0，就唤醒下一个节点        // 还记得waitStatus吗？        // 在每个节点阻塞之前会把其上一个节点的等待状态设为SIGNAL（-1）        // 所以，SIGNAL的准确理解应该是唤醒下一个等待的线程        if (h != null && h.waitStatus != 0)            unparkSuccessor(h);        return true;    }    return false;}// java.util.concurrent.locks.ReentrantLock.Sync.tryReleaseprotected final boolean tryRelease(int releases) {    int c = getState() - releases;    // 如果当前线程不是占有着锁的线程，抛出异常    if (Thread.currentThread() != getExclusiveOwnerThread())        throw new IllegalMonitorStateException();    boolean free = false;    // 如果状态变量的值为0了，说明完全释放了锁    // 这也就是为什么重入锁调用了多少次lock()就要调用多少次unlock()的原因    // 如果不这样做，会导致锁不会完全释放，别的线程永远无法获取到锁    if (c == 0) {        free = true;        // 清空占有线程        setExclusiveOwnerThread(null);    }    // 设置状态变量的值    setState(c);    return free;}private void unparkSuccessor(Node node) {    // 注意，这里的node是头节点
    // 如果头节点的等待状态小于0，就把它设置为0    int ws = node.waitStatus;    if (ws < 0)        compareAndSetWaitStatus(node, ws, 0);
    // 头节点的下一个节点    Node s = node.next;    // 如果下一个节点为空，或者其等待状态大于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;    }    // 如果下一个节点不为空，则唤醒它    if (s != null)        LockSupport.unpark(s.thread);}