@[TOC]
前言
了解ReentrantLock的原理和底層實現
一、ReentrantLock是如何實現的？
ReentrantLock 主要利用CAS 和 AQS隊列實現，并且支持公平鎖和非公平鎖。
CAS：Compare and Swap，比較并交換。在java中，CAS主要由Unsafe類通過JIN調用CPU底層代碼實現。
CAS有三個參數：內存值V、預期值A、新值B。當且僅當，預期值A和內存值V相同時，將內存值修改為B，否則不做修改。
關于AQS，參見文章AQS隊列
二、lock 和 unlock的過程分析
2.1 ReentrantLock的兩個構造器
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
默認構造器會將其實例化為NonfairSync對象，即非公平鎖，而帶參數的構造器可以指定使用公平鎖還是非公平鎖。
2.2 lock過程
NonfairSync.lock
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
非公平鎖的lock方法中，首先是一個CAS操作，判斷state是否是0，即當前鎖是否被其他線程占用了；如果是0，則設置為1，且設置當前線程為獨占線程。這里CAS操作避免了并發操作的問題。
這里也是第一處體現非公平鎖：如果此處占用鎖的線程剛剛好釋放鎖，則當前線程可以直接獲取鎖，而無需排隊，相當于直接“插隊”。
若此處沒有設置成功，即沒有獲取鎖，則會執行acquire()方法。
acquire()
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
第一步是調用tryAcquire()方法，嘗試獲取鎖。
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) { //狀態為0，沒有線程占用鎖
if (compareAndSetState(0, acquires)) {
//與lock方法里一樣，直接獲取鎖
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; // 獲取鎖失敗，返回false
}
這里第二次體現了不公平鎖。
這里還檢驗了是不是當前線程已經獲取鎖，而又重新獲取鎖。這里體現了重入鎖。會更新狀態值為重入的次數。
第二步addWaiter(Node.EXCLUSIVE)。
private Node addWaiter(Node mode) {
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;
}
這個添加到隊列的方法在上篇文章AQS已經分析過了，就不詳細分析了。
第三步acquireQueued()，此方法是讓隊列中的線程嘗試獲取鎖，如果失敗則掛起線程。
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true; // 標記是否獲取鎖成功
try {
boolean interrupted = false; // 線程中斷標志
for (;;) { // 自旋
final Node p = node.predecessor(); // 獲得前驅節點
// 如果該節點的前驅節點是head，則該節點是隊列中的第一個線程，可以嘗試互毆去鎖
if (p == head && tryAcquire(arg)) {
setHead(node); // 獲取鎖成功
p.next = null; // help GC，不然GC無法回收
failed = false; // 獲取鎖成功
return interrupted; //返回中斷標志，沒有被中斷
}
// 如果獲取失敗，是否可以掛起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node); // 最后取消嘗試獲取鎖
}
}
當上述方法獲取鎖失敗之后，就會判斷線程是否需要掛起。下面說明下shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()方法。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
// 前驅節點的狀態
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true; // 如果前驅節點狀態是SIGNAL，則返回true，可以掛起
// 前驅節點是CANCELLED
if (ws > 0) {
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
// 從隊尾向前循環查找，直到找到第一個不為CANCELLED的節點
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
// 設置前驅節點狀態為SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
// 掛起當前線程，并返回線程中斷狀態
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
這里解釋下，線程掛起的前提是，前驅節點是SIGNAL狀態。那SIGNAL狀態的含義是什么？SIGNAL表示其前驅節點線程如果獲取鎖，退出隊列，則將其喚醒。
2.3 unlock過程
unlock
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); // 如果頭節點不為空且不為狀態不為0，則取消掛起
return true; // 釋放成功
}
return false; // 釋放失敗
}
這里先嘗試釋放鎖，如果成功，就將頭節點取消掛起。
tryRealase
protected final boolean tryRelease(int releases) {
// 當前鎖狀態值減去釋放值，注意考慮重入鎖，不是直接置為0
int c = getState() - releases;
// 如果不是當前線程占用鎖，則拋出異常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) { // 如果狀態值等于0，則釋放鎖成功
free = true;
// 清空獨占線程
setExclusiveOwnerThread(null);
}
// 更新state 值
setState(c);
return free;
}
三、公平鎖和非公平鎖的區別
下面介紹非公平鎖和公平鎖的區別，公平鎖在獲取鎖之前， 不會直接CAS去獲取鎖，而是先判斷當前鎖狀態是不是等于0且當前線程是不是隊列中第一個線程，state=0才去嘗試獲得鎖。
protected final boolean tryAcquire(int acquires) {
// 獲取當前線程
final Thread current = Thread.currentThread();
// 獲取鎖狀態
int c = getState();
if (c == 0) { // 如果鎖沒有被任何線程擁有
// 當前線程是CLH隊列的的第一個線程，則取獲取鎖
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;
}
}
四、Synchronized和ReentrantLock的區別
4.1 功能區別
Synchronized是Java語言的關鍵字，是通過JVM實現的。
ReentrantLock是API層面的一種互斥鎖，而且它的鎖粒度和靈活性都優于Synchronized。
Synchronized使用較為簡單方便，由編譯器去保證鎖的加鎖和釋放。而ReentrantLock需要手動加鎖和釋放鎖，如果忘記手工釋放鎖，會造成死鎖。
4.2 性能區別
在Synchronized優化之前，性能是比較差的，因為都是重量級鎖。但是Synchronized引入偏向鎖，輕量級鎖之后，兩者的性能相差不大。當不需要使用ReentrantLock的特有性質時，官方建議使用Synchronized。
4.3 ReentrantLock的特有性質
等待可中斷：持有鎖的線程長期不釋放的時候，正在等待的線程可以選擇放棄等待，這相當于Synchronized來說可以避免出現死鎖的情況。通過lock.lockInterruptibly()來實現這個機制。
公平鎖：多個線程等待同一個鎖時，必須按照申請鎖的時間順序獲得鎖，Synchronized鎖是非公平鎖，ReentrantLock可以實現公平鎖。
選擇性通知（鎖綁定多個條件）：一個ReentrantLock可以同時綁定多個對象，然后通過condition（條件）類，來分組喚醒線程，而Synchronized是隨機喚醒一個線程或者所有線程。
