public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;
 
    /**
     * Base of synchronization control for this lock. Subclassed
     * into fair and nonfair versions below. Uses AQS state to
     * represent the number of holds on the lock.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
 
        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();
        // ...
    }
    // ...
}

public class CountDownLatch {
    /**
     * Synchronization control For CountDownLatch.
     * Uses AQS state to represent count.
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
 
        Sync(int count) {
            setState(count);
        }
 
        int getCount() {
            return getState();
        }
 
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
        // ...
    }
    // ...
}

public class ReentrantReadWriteLock
        implements ReadWriteLock, java.io.Serializable {
    private static final long serialVersionUID = -6992448646407690164L;
    /** Inner class providing readlock */
    private final ReentrantReadWriteLock.ReadLock readerLock;
    /** Inner class providing writelock */
    private final ReentrantReadWriteLock.WriteLock writerLock;
    /** Performs all synchronization mechanics */
    final Sync sync;
 
    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * default (nonfair) ordering properties.
     */
    public ReentrantReadWriteLock() {
        this(false);
    }
 
    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * the given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }
 
    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }
 
    /**
     * Synchronization implementation for ReentrantReadWriteLock.
     * Subclassed into fair and nonfair versions.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 6317671515068378041L;
        // ...
    }
    // ...
}

public class Semaphore implements java.io.Serializable {
    private static final long serialVersionUID = -3222578661600680210L;
    /** All mechanics via AbstractQueuedSynchronizer subclass */
    private final Sync sync;
 
    /**
     * Synchronization implementation for semaphore.  Uses AQS state
     * to represent permits. Subclassed into fair and nonfair
     * versions.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 1192457210091910933L;
        // ...
    }
    // ...
}

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
 
    private static final long serialVersionUID = 7373984972572414691L;
    protected AbstractQueuedSynchronizer() { }
    
    static final class Node {
        // ...
    }
 
    private transient volatile Node head;
 
    private transient volatile Node tail;
 
    // 同步状态的标识
    private volatile int state;
 
    protected final int getState() {
        return state;
    }
    // ...
}

public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    
    private final Sync sync;
    
    abstract static class Sync extends AbstractQueuedSynchronizer {...}
    
    static final class NonfairSync extends Sync {...}
    
    static final class FairSync extends Sync {...}
    
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
}

public ReentrantLock() {sync = new NonfairSync();}
public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();}

// 创建的是公平锁
private ReentrantLock lock = new ReentrantLock(true);
 
// 创建的是非公平锁
private ReentrantLock lock = new ReentrantLock(false);
 
// 默认创建非公平锁
private ReentrantLock lock = new ReentrantLock();

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;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;
 
    /**
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     */
    @ReservedStackAccess
    final void lock() {
        // 第一个线程抢占
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            // 第二个线程以及后续线程抢占
            acquire(1);
    }
 
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

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

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

final boolean nonfairTryAcquire(int acquires) {
    // 获取当前尝试获取锁的线程实例
    final Thread current = Thread.currentThread();
    // 获取当前锁的状态，通常状态0表示锁是空闲的，任何正数值表示锁被持有（在可重入锁的情况下，这个数值表示锁的持有次数）
    int c = getState();
    // 如果当前锁是空闲的（即状态为0）
    if (c == 0) {
        // 尝试通过CAS来设置锁的状态，如果设置成功，意味着当前线程成功获取了锁
        if (compareAndSetState(0, acquires)) {
            // 将当前线程设置为该锁的独占所有者
            setExclusiveOwnerThread(current);
            // 返回true表示获取锁成功。
            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;
    }
    // 如果上述条件都不满足，即当前线程既不是尝试获取一个空闲的锁，也不是尝试增加已经由自己持有的锁的重入次数，那么方法返回false，表示获取锁失败。
    return false;
}

private Node addWaiter(Node mode) {
    // 创建一个新的节点node，这个节点包含了当前线程和传入的模式（mode），模式可能指示了节点是独占模式还是共享模式。
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    // 如果当前的尾节点（pred，即前驱节点）不为空
    if (pred != null) {
        // 新节点的前驱就设置为这个尾节点，并尝试使用compareAndSetTail原子操作更新尾节点为新节点。如果这个原子操作成功，意味着新节点已经被成功地添加到队列的末尾，此时将前驱节点的下一个节点指向新节点，然后返回新节点。
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 调用入队方法
    enq(node);
    return node;
}

private Node enq(final Node node) {
    for (;;) {
        // 获取当前尾节点
        Node t = tail;
        // 判断队列是否为空
        if (t == null) { // Must initialize
            // 尝试通过compareAndSetHead原子操作创建一个新的空节点作为头节点（head）。如果成功，同时将tail也指向这个新的头节点。这个步骤是初始化同步队列的过程。
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 设置新节点的prev字段为当前的尾节点t，这样就建立了新节点向前的链接。
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                // 将原尾节点t的next字段指向新节点node，这样就完成了新节点的插入，并建立了从旧尾节点到新尾节点的链接。
                t.next = node;
                return t;
            }
        }
    }
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            // 拿到node的前驱节点
            final Node p = node.predecessor();
            // node的前驱节点是头节点并且tryAcquire尝试抢锁成功
            if (p == head && tryAcquire(arg)) {
                // 将当前节点设置为头节点，这标志着当前线程已成功获取资源。
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 检查是否应该挂起
            // 如果当前线程的资源获取尝试失败，并且根据shouldParkAfterFailedAcquire(p, node)的结果决定当前线程应该被挂起等待，则调用parkAndCheckInterrupt()挂起当前线程。如果在挂起过程中线程被中断，则interrupted被设置为true。
            // 如果前驱节点的 waitStatis 是SIGNAL状态，即shouldParkAfterFailedAcquire方法会返回 true，程序会继续向下执行parkAndCheckInterrupt方法，用于将当前线程挂起
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            // 取消这次资源获取尝试
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取当前节点的前驱节点的等待状态
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        // 这表示前驱节点已经处于等待唤醒（通知）后继节点的状态。在这种情况下，当前节点可以安全地挂起，因为它知道当前驱节点释放资源或被唤醒时，它将收到通知。
        return true;
    if (ws > 0) {
        // 这表示前驱节点被取消。在AQS框架中，取消的节点是不会参与到资源获取的竞争中，也不会转发唤醒信号。因此，如果前驱节点被取消，当前节点需要跳过被取消的节点，向前回溯找到一个未被取消的节点作为新的前驱节点。这个过程一直持续，直到找到一个等待状态不大于0的节点。然后，更新当前节点的前驱节点，以及新前驱节点的后继节点。这种情况下，方法返回false，因为需要重新尝试获取资源而不是直接挂起。
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 如果前驱节点的等待状态既不是SIGNAL也不是被取消（即等待状态为0或PROPAGATE），这表示需要设置前驱节点的等待状态为SIGNAL，让它知道在释放资源或者被唤醒时需要通知后继节点。这是通过compareAndSetWaitStatus原子操作完成的。在这种情况下，方法同样返回false，表示当前节点不应该立即挂起，而是应该再次尝试获取资源，如果失败，那么在下一轮迭代中可能会决定挂起。
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

// parkAndCheckInterrupt方法实现了在等待某个条件满足时挂起线程的功能，并在线程被唤醒时检查是否是因为中断而唤醒。如果线程确实因为中断被唤醒，方法返回true，允许调用者处理中断情况。
private final boolean parkAndCheckInterrupt() {
    // 这一行调用LockSupport类的park方法来挂起当前线程。LockSupport是Java并发包中的一个工具类，提供了基本的线程同步机制。park方法可以阻塞当前线程直到它被unpark调用唤醒，或者被中断。
    LockSupport.park(this);
    // 根据park方法API描述，程序在下述三种情况下会继续向下执行
    // 1.被unpark
    // 2.被中断（interrupt）
    // 3.其他不合逻辑的返回才会继续向下执行
    
    // 检查当前线程是否被中断，并且清除当前线程的中断状态。
    // 如果被中断，返回true
    return Thread.interrupted();
}

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

public final boolean release(int arg) {
    // 调用抽象方法tryRelease尝试释放锁
    if (tryRelease(arg)) {
        Node h = head;
        // 如果头节点存在且头节点的等待状态（waitStatus）不为0（即，不是初始状态），这表示队列中可能有因为等待资源而被挂起的线程。
        if (h != null && h.waitStatus != 0)
            // 调用unparkSuccessor(h)方法来唤醒头节点的后继节点
            unparkSuccessor(h);
        return true;
    }
    return false;
}

// 该方法的目的是唤醒在同步队列中等待的后继线程。
private void unparkSuccessor(Node node) {
    
    int ws = node.waitStatus;
    // 检查传入的节点（通常是同步队列的头节点）的等待状态（waitStatus）。如果状态是负数，这表示节点可能在等待一个信号（唤醒）。方法尝试将节点的等待状态更新为0，以预期发送信号。
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
 
    // 找到当前线程的后继节点
    Node s = node.next;
    // 判断后继节点不存在（null）或者已被取消（waitStatus大于0）
    if (s == null || s.waitStatus > 0) {
        // 从同步队列的尾部开始向前遍历，寻找第一个未被取消的后继节点（即，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);
}