[Java 并发]带你从源码解读 ReentrantLock 就不信还搞不定它!

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.
    */
    // 重写 Sync 的 lock 方法
    final void lock() {
    	// 先不管其他,上来就先 CAS 操作,尝试抢占一下锁
        if (compareAndSetState(0, 1))
        	// 如果抢占成功,就获得了锁
            setExclusiveOwnerThread(Thread.currentThread());
        else
        	// 没有抢占成功,调用 acquire() 方法,走里面的逻辑
            acquire(1);
    }
	// 重写了 AQS 的 tryAcquire 方法
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

	// 重写 Sync 的 lock 方法
    final void lock() {
        acquire(1);
    }

    /**
    * Fair version of tryAcquire.  Don't grant access unless
    * recursive call or no waiters or is first.
    */
    // 重写了 Sync 的 tryAcquire 方法
    protected final boolean tryAcquire(int acquires) {
    	// 获取当前执行的线程
        final Thread current = Thread.currentThread();
        // 获取 state 的值
        int c = getState();
        // 在无锁状态下
        if (c == 0) {
        	// 没有前驱节点且替换 state 的值成功时
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                // 保存当前获得锁的线程,下次再来时,就不需要尝试竞争锁,直接重入即可
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
        	// 如果是同一个线程来获得锁,直接增加重入次数即可
            int nextc = c + acquires;
            // nextc 小于 0 ,抛异常
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            // 获取锁成功
            return true;
        }
        // 获取锁失败
        return false;
    }
}

final void lock() {
	// 不管别的,上来就先 CAS 操作,尝试抢占一下锁
    if (compareAndSetState(0, 1))
    	// 如果抢占成功,就获得了锁
        setExclusiveOwnerThread(Thread.currentThread());
    else
    	// 没有抢占成功,调用 acquire() 方法,走里面的逻辑
        acquire(1);
}

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

protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

final boolean nonfairTryAcquire(int acquires) {
	// 获取当前执行的线程
    final Thread current = Thread.currentThread();
    // 获取 state 的值
    int c = getState();
    // 当 state 为 0 是,说明此时为无锁状态
    if (c == 0) {
    	// CAS 替换 state 的值,如果 CAS 成功,则获取锁成功
        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;
}

private Node addWaiter(Node mode) {
	// 生成该线程所对应的 Node 节点
    Node node = new Node(Thread.currentThread(), mode);
    // 将 Node 插入队列中
    Node pred = tail;
    // 如果 pred 不为空
    if (pred != null) {
        node.prev = pred;
        // 使用 CAS 操作,如果成功就返回
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 如果 pred == null 或者 CAS 操作失败,则调用 enq 方法再次自旋插入
    enq(node);
    return node;
}

// 自旋 CAS 插入等待队列
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
        	// 必须初始化,使用 CAS 操作进行初始化
            if (compareAndSetHead(new Node()))
            	// 初始化状态时,头尾节点指向同一节点
                tail = head;
        } else {
            node.prev = t;
            // 如果刚开始就是初始化好的,直接 CAS 操作,将 Node 插入到队尾即可
            if (compareAndSetTail(t, node)) {
                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();
            // 如果 Node 的前驱节点 p 是 head,说明 Node 是第二个节点,那么它就可以尝试获取锁
            if (p == head && tryAcquire(arg)) {
            	// 如果锁获取成功,则将 head 指向自己
                setHead(node);
                // 锁获取成功之后,将 next 指向 null ,即将节点 p 从队列中移除
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 节点进入等待队列后,调用 shouldParkAfterFailedAcquire 或者 parkAndCheckInterrupt 方法
            // 进入阻塞状态,即只有头结点的线程处于活跃状态
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	// 获取 pred 的状态
    int ws = pred.waitStatus;
    // 如果状态为 SIGNAL ,那么直接返回 true ,挂起线程即可
    if (ws == Node.SIGNAL)
        return true;
    // 如果状态大于 0 ,说明线程被取消
    if (ws > 0) {
    	// 从链表中移除被 cancel 的线程,使用循环来保证移除成功
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
    	// CAS 操作修改 pred 节点状态为 SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 不需要挂起线程
    return false;
}

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

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

public final boolean release(int arg) {
	// 如果释放锁成功
    if (tryRelease(arg)) {
    	// 获取 AQS 队列的头结点
        Node h = head;
        // 如果头结点不为空,且状态 != 0
        if (h != null && h.waitStatus != 0)
        	// 调用 unparkSuccessor 方法唤醒后续节点
            unparkSuccessor(h);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    // 判断当前线程是否为获取到锁的线程,如果不是则抛出异常
    // 只有获取到锁的线程才释放锁
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 次数为 0 ,说释放锁完毕
    if (c == 0) {
        free = true;
        // 释放之后,当前线程置为 null
        setExclusiveOwnerThread(null);
    }
    // 更新重入次数
    setState(c);
    return free;
}

private void unparkSuccessor(Node node) {
	// 获取当前节点的状态
    int ws = node.waitStatus;
    // 如果节点状态小于 0 ,则进行 CAS 操作设置为 0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
   	// 获取当前节点的下一个节点 s
    Node s = node.next;
    // 如果 s 为空,则从尾部节点开始,或者s.waitStatus 大于 0 ,说明节点被取消
    // 从尾节点开始,寻找到距离 head 节点最近的一个 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;
    }
    if (s != null)
    	// next 节点不为空,直接唤醒即可
        LockSupport.unpark(s.thread);
}