public class ReentrantLock implements Lock {
    private final Sync sync;
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // 實(shí)現(xiàn)鎖的基本操作
    }
    // 公平鎖實(shí)現(xiàn)
    static final class FairSync extends Sync { ... }
    // 非公平鎖實(shí)現(xiàn)
    static final class NonfairSync extends Sync { ... }
}

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);
    // 嘗試快速添加到隊(duì)列尾部
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 快速添加失敗，進(jìn)入完整的入隊(duì)方法
    enq(node);
    return node;
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            // 獲取前驅(qū)節(jié)點(diǎn)
            final Node p = node.predecessor();
            // 如果前驅(qū)是頭節(jié)點(diǎn)，說(shuō)明輪到當(dāng)前節(jié)點(diǎn)嘗試獲取鎖
            if (p == head && tryAcquire(arg)) {
                // 獲取成功，把當(dāng)前節(jié)點(diǎn)設(shè)為頭節(jié)點(diǎn)
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 判斷是否應(yīng)該阻塞當(dāng)前線程
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    // 獲取當(dāng)前節(jié)點(diǎn)的等待狀態(tài)
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 找到下一個(gè)需要喚醒的節(jié)點(diǎn)
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 從尾部向前查找需要喚醒的節(jié)點(diǎn)
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 喚醒找到的節(jié)點(diǎn)
    if (s != null)
        LockSupport.unpark(s.thread);
}

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 非公平鎖直接嘗試CAS獲取鎖，不檢查隊(duì)列
        if (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;
    }
    return false;
}

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 公平鎖會(huì)先調(diào)用hasQueuedPredecessors檢查是否有前驅(qū)節(jié)點(diǎn)在等待
        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;
    }
    return false;
}

public class SimpleReentrantLock implements Lock {
    private final Sync sync;
    /**
     * 默認(rèn)創(chuàng)建非公平鎖
     */
    public SimpleReentrantLock() {
        sync = new NonfairSync();
    }
    /**
     * 根據(jù)參數(shù)創(chuàng)建公平鎖或非公平鎖
     */
    public SimpleReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    /**
     * 繼承AQS的同步器實(shí)現(xiàn)
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
        /**
         * 非公平的方式獲取鎖
         */
        final boolean unfairTryAcquire(int acquires) {
            // 獲取當(dāng)前線程
            final Thread current = Thread.currentThread();
            // 獲取當(dāng)前state狀態(tài)
            int c = getState();
            // state為0表示鎖未被持有
            if (c == 0) {
                // 使用CAS嘗試將state從0設(shè)置為1
                if (compareAndSetState(0, acquires)) {
                    // 成功獲取鎖，設(shè)置當(dāng)前持有鎖的線程為當(dāng)前線程
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 如果當(dāng)前線程就是持有鎖的線程，實(shí)現(xiàn)可重入
            else if (current == getExclusiveOwnerThread()) {
                // 增加state值實(shí)現(xiàn)重入計(jì)數(shù)
                int nextC = c + acquires;
                // 檢查溢出
                if (nextC < 0) {
                    throw new Error("Maximum lock count exceeded");
                }
                // 設(shè)置新的state值，這里不需要CAS因?yàn)楫?dāng)前線程已經(jīng)持有鎖
                setState(nextC);
                return true;
            }
            // 獲取鎖失敗
            return false;
        }
        /**
         * 釋放鎖
         */
        @Override
        protected final boolean tryRelease(int releases) {
            // 檢查當(dāng)前線程是否是持有鎖的線程
            if (Thread.currentThread() != getExclusiveOwnerThread()) {
                throw new IllegalMonitorStateException();
            }
            // 減少state值
            int c = getState() - releases;
            // 判斷是否完全釋放鎖
            boolean free = (c == 0);
            if (free) {
                // 完全釋放鎖，清空持有鎖的線程
                setExclusiveOwnerThread(null);
            }
            // 更新state值
            setState(c);
            return free;
        }
        /**
         * 判斷當(dāng)前線程是否持有鎖
         */
        @Override
        protected boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
        /**
         * 創(chuàng)建條件變量
         */
        Condition newCondition() {
            return new ConditionObject();
        }
        /**
         * 獲取鎖的持有計(jì)數(shù)
         */
        public int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }
    }
    /**
     * 公平鎖的實(shí)現(xiàn)
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        @Override
        protected boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                // 公平性體現(xiàn)：先檢查隊(duì)列中是否有前驅(qū)節(jié)點(diǎn)在等待
                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;
            }
            return false;
        }
    }
    /**
     * 非公平鎖的實(shí)現(xiàn)
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        /**
         * 非公平鎖的獲取實(shí)現(xiàn)
         */
        @Override
        protected boolean tryAcquire(int acquires) {
            return unfairTryAcquire(acquires);
        }
    }
    // 實(shí)現(xiàn)Lock接口的方法
    @Override
    public void lock() {
        sync.acquire(1);
    }
    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
    @Override
    public boolean tryLock() {
        return sync.unfairTryAcquire(1);
    }
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }
    @Override
    public void unlock() {
        sync.release(1);
    }
    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }
    /**
     * 查詢當(dāng)前鎖是否被某個(gè)線程持有
     */
    public boolean isLocked() {
        return sync.isHeldExclusively();
    }
    /**
     * 查詢當(dāng)前線程是否持有鎖
     */
    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }
    /**
     * 獲取當(dāng)前鎖的持有計(jì)數(shù)
     */
    public int getHoldCount() {
        return sync.getHoldCount();
    }
}

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    // 添加到條件隊(duì)列
    Node node = addConditionWaiter();
    // 完全釋放鎖
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    // 循環(huán)檢查節(jié)點(diǎn)是否已經(jīng)轉(zhuǎn)移到同步隊(duì)列
    while (!isOnSyncQueue(node)) {
        // 阻塞當(dāng)前線程
        LockSupport.park(this);
        // 檢查中斷
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    // 重新競(jìng)爭(zhēng)鎖
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null)
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}