ReentrantLock

JUC中ReentrantLock實現了獨佔模式重入鎖，對於可重入，此類的註釋是這樣的：

當一個執行緒鎖住ReentrantLock，但是沒有解鎖，這個執行緒再執行加鎖方法會返回成功，並獲得這把鎖

ReentrantLock類圖

由上圖可知，ReentrantLock包含兩個靜態屬性，一個是java 序列化Serializable使用的屬性serialVersionUID，一個是sync，sync是內部類Sync的例項，ReentrantLock中還包含兩個另外兩個子類FairSync，NonfairSync。它們都繼承自Sync類。FairSync是公平鎖的實現方式，NonfairSync是非公平鎖的實現方式。他們兩都實現了可重入。

ReentrantLock初始化

ReentrantLock有兩個不同的初始化方法

public ReentrantLock() {
       //預設方式：設定sync屬性為非公平模式鎖NonfairSync例項
       sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
   //根據使用者傳入是否公平引數，設定sync屬性為非公平模式鎖NonfairSync或者公平模式鎖FairSync例項
   sync = fair ? new FairSync() : new NonfairSync();
}
 

ReentrantLock加鎖解鎖

ReentrantLock解鎖解鎖執行的都是sync的方法

//加鎖
public void lock() {
    sync.lock();
}
//可中斷加鎖
public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}
//嘗試加鎖
public boolean tryLock() {
    return sync.nonfairTryAcquire(1);//使用非公平模式獲取一次鎖
}
//帶時間限制的嘗試加鎖
public
 
 boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
   return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
//釋放鎖
public void unlock() {
    sync.release(1);
}

Sync加鎖解鎖

Sync的加鎖方法是一個abstract 方法，交由子類實現

abstract void lock();

公平重入鎖

其中公平重入鎖方式直接呼叫aqs的acquire，然後自身實現了aqs acquire方法會呼叫的tryAcquire方法（aqs的流程詳見上一篇aqs的介紹）。其中tryAcquire獲取鎖首先會判斷當前state是否為0。
如果不為0則代表鎖已被鎖住，如果被鎖住，則檢視佔用的執行緒是否為當前執行緒。如果是當前執行緒佔用了這個鎖，則可重入，進行state增加。state可以表示持有者重入次數。
如果為0，則判斷當前執行緒代表的節點在佇列中有沒有在排隊的前任，如果沒有在排隊的前任則嘗試獲取鎖。因為新加入獲取鎖佇列的節點都是加在佇列的尾部。而只有佇列中沒有前任在排隊獲取鎖的節點才能嘗試獲取鎖，維持了一個先進先出的規則。所有執行緒都是根據進入順序去持有鎖的，是公平的方式。

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;
         }
     }
     //如果持有鎖的為自己，則重入state+=acquires
     else if (current == getExclusiveOwnerThread()) {
         int nextc = c + acquires;
         if (nextc < 0)
             throw new Error("Maximum lock count exceeded");
         setState(nextc);
         return true;
     }
     return false;
 }

非公平重入鎖

非公平重入鎖NonfairSync 在呼叫lock方法時會快速cas嘗試修改state狀態0->1，如果成功則設定鎖持有者為自身，不去管是否有其他執行緒在等待。是非公平的方式。當cas不成功時，則呼叫acquire,並且NonfairSync 自身也和FairSync類一樣，實現了acquire會呼叫的tryAcquire方法。tryAcquire方法使用的是父類Sync的非公平嘗試獲取鎖方法nonfairTryAcquire

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

nonfairTryAcquire方法與FairSync類的tryAcquire不同點在於這個方法實現的不公平方式不會判斷是否有前任在排隊。直接進行嘗試獲取鎖。會造成插隊情況，是不公平獲取鎖的形式，但是比公平方式少了一些判斷，效能更優。
nonfairTryAcquire的重入方式與公平鎖FairSync的一樣。

final boolean nonfairTryAcquire(int acquires) {
  final Thread current = Thread.currentThread();
  int c = getState();
  if (c == 0) {
      //如果狀態為0，當前鎖未鎖住，嘗試cas修改狀態
      if (compareAndSetState(0, acquires)) {
          //設定當前執行緒為鎖的獨佔執行緒
          setExclusiveOwnerThread(current);
          return true;
      }
  }
  //如果佔據鎖的執行緒是當前執行緒，state+=acquires
  else if (current == getExclusiveOwnerThread()) {
      int nextc = c + acquires;
      if (nextc < 0) // overflow
          throw new Error("Maximum lock count exceeded");
      setState(nextc);
      return true;
  }

ReentrantLock unlock

ReentrantLock unlock呼叫的Sync的父類AQS的release方法釋放鎖。而Sync實現了release方法會呼叫的tryRelease。tryRelease會使鎖狀態state減少，呼叫一次則state減少1，代表重入次數減少一次。當減少到為0時，表示當前執行緒沒有持有該鎖，將鎖的持有者置為空。

 protected final boolean tryRelease(int releases) {
            //state-=releases
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                //如果state為0，設定鎖的所有者為空
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

總結

ReentrantLock的重入為當持有鎖的為當前執行緒時，重入，將鎖狀態state增加。
ReentrantLock的公平非公平模式，交由Sync的兩個子類控制，區別在於公平模式只有沒有前任在排隊的情況下才可以獲取鎖。公平模式不進行這個判斷。直接嘗試獲取鎖，可插隊。