public interface Lock {
    //獲取鎖，若當(dāng)前鎖被其他線程獲取，則此線程會阻塞等待lock被釋放
    //使用lock方法需要顯式地去釋放鎖，即使發(fā)生異常時也不會自動釋放鎖。
    void lock();
    //作用同lock方法，并且在獲取鎖的過程中可以響應(yīng)中斷
    void lockInterruptibly() throws InterruptedException;
    //嘗試獲取鎖，獲取成功返回true，失敗則返回false
    //即該方法不會導(dǎo)致線程阻塞，無論如何都會返回
    boolean tryLock();
    //作用同tryLock方法，如果獲取到鎖直接返回true
    //新增的特性是如果獲取不到鎖，會等待一段時間，且在等待的過程可以響應(yīng)中斷，一旦超過等待時間仍獲取不到鎖，就返回false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    //釋放鎖
    void unlock();
    //返回一個綁定該lock的Condition對象，這個后續(xù)在Condition專題會詳細講解，本文先不贅述
    Condition newCondition();
}

//創(chuàng)建lock實例
Lock lock = new ReentrantLock();
try {
    //加鎖
    lock.lock();
    // do something...
} finally {
    //解鎖
    lock.unlock();
}

public class ReentrantLock implements Lock, java.io.Serializable

abstract static class Sync extends AbstractQueuedSynchronizer {
    //序列化版本號
    private static final long serialVersionUID = -5179523762034025860L;
    //獲取鎖，需要子類自己實現(xiàn)
    abstract void lock();
    //非公平方式獲取鎖
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                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;
        }
        return false;
    }
    //釋放鎖
    protected final boolean tryRelease(int releases) {
        int c = getState() - releases;
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }
    //判斷資源釋放被當(dāng)前線程占用
    protected final boolean isHeldExclusively() {
        return getExclusiveOwnerThread() == Thread.currentThread();
    }
    //創(chuàng)建一個新條件
    final ConditionObject newCondition() {
        return new ConditionObject();
    }
    // 返回占有資源的線程
    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }
    //返回狀態(tài)
    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }
    //判斷資源是否被占用
    final boolean isLocked() {
        return getState() != 0;
    }
    //自定義反序列化
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

static final class NonfairSync extends Sync {
    //序列化版本號
    private static final long serialVersionUID = 7316153563782823691L;
    //獲取鎖
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }
    //嘗試獲取鎖
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

static final class FairSync extends Sync {
    //序列化版本號
    private static final long serialVersionUID = -3000897897090466540L;
    //獲取鎖
    final void lock() {
        acquire(1);
    }
    //嘗試公平獲取鎖
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            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;
    }
}

//序列化版本號
private static final long serialVersionUID = 7373984872572414699L;
//同步器，繼承自AQS，提供各種核心操作
private final Sync sync;

//無參構(gòu)造函數(shù)，默認為非公平鎖
public ReentrantLock() {
    sync = new NonfairSync();
}
//有參構(gòu)造函數(shù)，傳遞boolean類型參數(shù)fair
//fair=false：非公平鎖
//fair=true：公平鎖
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

lock.lock();

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

final void lock() {
    acquire(1);
}

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

protected final boolean tryAcquire(int acquires) {
    //獲取當(dāng)前線程
    final Thread current = Thread.currentThread();
    //獲取同步狀態(tài)
    int c = getState();
    //如果同步狀態(tài)為0表示當(dāng)前資源空閑
    if (c == 0) {
        //在CAS獲取鎖前需要調(diào)用方法hasQueuedPredecessors來判斷隊列中是否存在其他正在排隊的節(jié)點，如果存在返回true，不僅如此if塊，否則返回false，進行CAS操作
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            //設(shè)置當(dāng)前資源的持有線程為當(dāng)前線程
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //如果c不等于0，且當(dāng)前持有鎖線程不等于當(dāng)前線程，直接返回false，加鎖失敗
    //如果c不等于0，且當(dāng)前持有鎖的線程等于當(dāng)前線程，表示這是一次重入，就會把狀態(tài)+1，結(jié)束后返回true，即重入鎖返回true
    //這塊代碼側(cè)面說明Reentrantlock是可以重入的
    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 final boolean hasQueuedPredecessors() {
	//保存尾結(jié)點
    Node t = tail; 
    //保存頭結(jié)點
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

h != t &&((s = h.next) == null || s.thread != Thread.currentThread())

final void lock() {
    //直接嘗試獲取鎖
    if (compareAndSetState(0, 1))
        //獲取鎖成功后
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

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

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

protected final boolean tryRelease(int releases) {
    //計算釋放后state值
    int c = getState() - releases;
    //如果獲取鎖的線程不是當(dāng)前線程，直接拋異常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    //鎖被重入的次數(shù)為0，表示鎖被釋放，清空獨占線程
    if (c == 0) {
        free = true;
        //清空獨占線程
        setExclusiveOwnerThread(null);
    }
    //設(shè)置state值
    setState(c);
    //返回鎖是否被釋放
    return free;
}