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

 // ReentrantLock.java
 public void lock() {
     sync.lock();
 }
 ?
 public boolean tryLock() {
     return sync.nonfairTryAcquire(1);
 }
 ?
 public void unlock() {
     sync.release(1);
 }

 // NonfairSync.java
 final void lock() {
     if (compareAndSetState(0, 1))
         setExclusiveOwnerThread(Thread.currentThread());
     else
         acquire(1);
 }

 // AbstractQueuedSynchronizer.java
 private volatile int state;
 protected final boolean compareAndSetState(int expect, int update) {
     // See below for intrinsics setup to support this
     return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
 }

 // AbstractOwnableSynchronizer.java
 private transient Thread exclusiveOwnerThread;
 ?
 protected final void setExclusiveOwnerThread(Thread thread) {
     exclusiveOwnerThread = thread;
 }

 // NonfairSync.java
 final void lock() {
     if (compareAndSetState(0, 1))
         setExclusiveOwnerThread(Thread.currentThread());
     else
         acquire(1);
 }
 ?
 // AbstractQueuedSynchronizer.java
 public final void acquire(int arg) {
     if (!tryAcquire(arg) &&
         acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
         selfInterrupt();
 }

 // NonfairSync.java
 protected final boolean tryAcquire(int acquires) {
     return nonfairTryAcquire(acquires);
 }

 // Sync.java
 final boolean nonfairTryAcquire(int acquires) {
     final Thread current = Thread.currentThread();
     // 獲取當前同步資源狀態(tài)
     int c = getState();
     // 同步資源空閑
     if (c == 0) {
         // 占用同步資源更新資源狀態(tài)
         if (compareAndSetState(0, acquires)) {
             // 設置當前線程為資源對應的獨占鎖持有者
             setExclusiveOwnerThread(current);
             return true;
         }
     }
     // 如果當前線程就是持有鎖線程，更新鎖狀態(tài)，直接持有鎖
     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;
 }

// AbstractQueuedSynchronizer.java
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;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

// AbstractQueuedSynchronizer.java
private Node addWaiter(Node mode) {
    // 創(chuàng)建新的Node對象
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

// Node實體類
static final class Node {
    ...
    // 前一個元素
    volatile Node prev;
    // 下一個元素
    volatile Node next;
    // 線程對象
    volatile Thread thread;
    Node() {    // Used to establish initial head or SHARED marker
    }
    Node(Thread thread, Node mode) {     // Used by addWaiter
        this.nextWaiter = mode;
        this.thread = thread;
    }
    Node(Thread thread, int waitStatus) { // Used by Condition
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
    ...
}
// AbstractQueuedSynchronizer.java中聲明Node對象
// 鏈表頭
private transient volatile Node head;
// 鏈表尾部
private transient volatile Node tail;

// AbstractQueuedSynchronizer.java
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;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

// AbstractQueuedSynchronizer.java
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

// ReentrantLock.java
public void unlock() {
    sync.release(1);
}
// AQS.java
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

static final class Node {
    ...
    // waitStatus的四種可能取值，表示當前節(jié)點及其后續(xù)節(jié)點對應線程的運行狀態(tài)
    static final int CANCELLED =  1;
    static final int SIGNAL    = -1;
    static final int CONDITION = -2;
    static final int PROPAGATE = -3;
    // 聲明waitStatus
    volatile int waitStatus;
    ...
}

protected final boolean tryRelease(int releases) {
    // 獲取AQS的鎖狀態(tài)標記，計算剩余鎖狀態(tài)標記
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 鎖狀態(tài)標記為0，當前沒有其他線程持有鎖，鎖處于空閑狀態(tài)，設置鎖持有者為null
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 更新鎖狀態(tài)
    setState(c);
    return free;
}

private void unparkSuccessor(Node node) {
    // 獲取頭節(jié)點的waitStatus狀態(tài)，將頭節(jié)點的waitStatus狀態(tài)設置為0，head waitStatus恢復初始狀態(tài)
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 獲取頭節(jié)點的下一個節(jié)點，如果下一個節(jié)點為null或者狀態(tài)為取消狀態(tài)(waitStatus大于0只有取消狀態(tài))，則從尾節(jié)點開始遍歷，查找未被取消的后續(xù)節(jié)點對象
    Node s = node.next;
    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;
    }
    // 對上一步獲取到的節(jié)點對應的線程執(zhí)行unpark喚醒，去搶占鎖
    if (s != null)
        LockSupport.unpark(s.thread);
}