public class ReentrantLock implements Lock, java.io.Serializable {}

// 獲得鎖方法，獲取不到鎖的線程會到同步隊列中阻塞排隊
void lock();
// 獲取可中斷的鎖
void lockInterruptibly() throws InterruptedException;
// 嘗試獲得鎖，如果鎖空閑，立馬返回 true，否則返回 false
boolean tryLock();
// 帶有超時等待時間的鎖，如果超時時間到了，仍然沒有獲得鎖，返回 false
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
// 釋放鎖
void unlock();
// 得到新的 Condition
Condition newCondition();

abstract static class Sync extends AbstractQueuedSynchronizer {}

// 同步器 Sync 的兩個子類鎖
static final class FairSync extends Sync {}
static final class NonfairSync extends Sync {}

// 無參數(shù)構(gòu)造器，相當于 ReentrantLock(false)，默認是非公平的
public ReentrantLock() {
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

// 嘗試獲得非公平鎖
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    // 同步器的狀態(tài)是 0，表示同步器的鎖沒有人持有
    if (c == 0) {
        // 當前線程持有鎖
        if (compareAndSetState(0, acquires)) {
            // 標記當前持有鎖的線程是誰
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 如果當前線程已經(jīng)持有鎖了，同一個線程可以對同一個資源重復加鎖，代碼實現(xiàn)的是可重入鎖
    else if (current == getExclusiveOwnerThread()) {
        // 當前線程持有鎖的數(shù)量 + acquires
        int nextc = c + acquires;
        // int 是有最大值的，<0 表示持有鎖的數(shù)量超過了 int 的最大值
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    //否則線程進入同步隊列
    return false;
}

public boolean tryLock() {
    // 入?yún)?shù)是 1 表示嘗試獲得一次鎖
    return sync.nonfairTryAcquire(1);
}

// 釋放鎖方法，非公平和公平鎖都使用
protected final boolean tryRelease(int releases) {
    // 當前同步器的狀態(tài)減去釋放的個數(shù)，releases 一般為 1
    int c = getState() - releases;
    // 當前線程根本都不持有鎖，報錯
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 如果 c 為 0，表示當前線程持有的鎖都釋放了
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 如果 c 不為 0，那么就是可重入鎖，并且鎖沒有釋放完，用 state 減去 releases 即可，無需做其他操作
    setState(c);
    return free;
}

// acquire 是 AQS 的方法，表示先嘗試獲得鎖，失敗之后進入同步隊列阻塞等待
final void lock() {
    acquire(1);
}

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // hasQueuedPredecessors 是實現(xiàn)公平的關鍵
        // 會判斷當前線程是不是屬于同步隊列的頭節(jié)點的下一個節(jié)點(頭節(jié)點是釋放鎖的節(jié)點)
        // 如果是(返回false)，符合先進先出的原則，可以獲得鎖
        // 如果不是(返回true)，則繼續(xù)等待
        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;
}

// 加鎖
final void lock() {
    // cas 給 state 賦值
    if (compareAndSetState(0, 1))
        // cas 賦值成功，代表拿到當前鎖，記錄拿到鎖的線程
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // acquire 是抽象類AQS的方法,
        // 會再次嘗試獲得鎖，失敗會進入到同步隊列中
        acquire(1);
}
// 直接使用的是 Sync.nonfairTryAcquire 方法 
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

public void lock() {
    sync.lock();
}

// 無參構(gòu)造器
public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}
// timeout 為超時的時間，在時間內(nèi)，仍沒有得到鎖，會返回 false
public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

// 釋放鎖
public void unlock() {
    sync.release(1);
}