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

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

abstract static class Sync extends AbstractQueuedSynchronizer {}

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

// 無參數(shù)構(gòu)造器，相當(dāng)于 ReentrantLock(false)，默認(rèn)是非公平的
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) {
        // 當(dāng)前線程持有鎖
        if (compareAndSetState(0, acquires)) {
            // 標(biāo)記當(dāng)前持有鎖的線程是誰
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 如果當(dāng)前線程已經(jīng)持有鎖了，同一個(gè)線程可以對(duì)同一個(gè)資源重復(fù)加鎖，代碼實(shí)現(xiàn)的是可重入鎖
    else if (current == getExclusiveOwnerThread()) {
        // 當(dāng)前線程持有鎖的數(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;
    }
    //否則線程進(jìn)入同步隊(duì)列
    return false;
}

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

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

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

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // hasQueuedPredecessors 是實(shí)現(xiàn)公平的關(guān)鍵
        // 會(huì)判斷當(dāng)前線程是不是屬于同步隊(duì)列的頭節(jié)點(diǎn)的下一個(gè)節(jié)點(diǎn)(頭節(jié)點(diǎn)是釋放鎖的節(jié)點(diǎn))
        // 如果是(返回false)，符合先進(jìn)先出的原則，可以獲得鎖
        // 如果不是(返回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 賦值成功，代表拿到當(dāng)前鎖，記錄拿到鎖的線程
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // acquire 是抽象類AQS的方法,
        // 會(huì)再次嘗試獲得鎖，失敗會(huì)進(jìn)入到同步隊(duì)列中
        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 為超時(shí)的時(shí)間，在時(shí)間內(nèi)，仍沒有得到鎖，會(huì)返回 false
public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

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