public?class?ReentrantLock?implements?Lock,?java.io.Serializable?{
????private?static?final?long?serialVersionUID?=?7373984872572414699L;
????/**?Synchronizer?providing?all?implementation?mechanics?*/
????private?final?Sync?sync;
??
??public?ReentrantLock()?{
????????sync?=?new?NonfairSync();
????}
?????abstract?static?class?Sync?extends?AbstractQueuedSynchronizer?{
???????……省略代碼
?????}
??
??//非公平鎖
??static?final?class?NonfairSync?extends?Sync?{
????????private?static?final?long?serialVersionUID?=?7316153563782823691L;

????????/**
?????????*?Performs?lock.??Try?immediate?barge,?backing?up?to?normal
?????????*?acquire?on?failure.
?????????*/
????????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);
????????}

????????/**
?????????*?Fair?version?of?tryAcquire.??Don't?grant?access?unless
?????????*?recursive?call?or?no?waiters?or?is?first.
?????????*/
????????protected?final?boolean?tryAcquire(int?acquires)?{
……省略
????????}
????}
??//?lock?方法本質(zhì)就是調(diào)用sync類
??public?void?lock()?{
????????sync.lock();
????}
}

final?void?lock()?{
????if?(compareAndSetState(0,?1))
????????setExclusiveOwnerThread(Thread.currentThread());
????else
????????acquire(1);
}

//AbstractQueuedSynchronizer
public?final?void?acquire(int?arg)?{
????if?(!tryAcquire(arg)?&&
????????acquireQueued(addWaiter(Node.EXCLUSIVE),?arg))
????????selfInterrupt();
}
//ReentrantLock.NonfairSync
protected?final?boolean?tryAcquire(int?acquires)?{
????return?nonfairTryAcquire(acquires);
}
//ReentrantLock.Sync
final?boolean?nonfairTryAcquire(int?acquires)?{
????final?Thread?current?=?Thread.currentThread();
????int?c?=?getState();
????if?(c?==?0)?{
??????//?cas再次嘗試獲取
????????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;
}

//?獲取鎖失敗
acquireQueued(addWaiter(Node.EXCLUSIVE),?arg))

//?加入同步隊列
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;
??????//?通過CAS設(shè)置尾節(jié)點為當(dāng)前節(jié)點，前驅(qū)節(jié)點為之前的尾節(jié)點。
????????if?(compareAndSetTail(pred,?node))?{
????????????pred.next?=?node;
????????????return?node;
????????}
????}
??//?如果當(dāng)前鏈表為空，則在此處進行初始化
????enq(node);
????return?node;
}
private?Node?enq(final?Node?node)?{
????for?(;;)?{
????????Node?t?=?tail;
????????if?(t?==?null)?{?//?Must?initialize
????????????if?(compareAndSetHead(new?Node()))
????????????????tail?=?head;
????????}?else?{
??????????//?追加到隊列尾
????????????node.prev?=?t;
????????????if?(compareAndSetTail(t,?node))?{
????????????????t.next?=?node;
????????????????return?t;
????????????}
????????}
????}
}

final?boolean?acquireQueued(final?Node?node,?int?arg)?{
????boolean?failed?=?true;
????try?{
????????boolean?interrupted?=?false;
????????for?(;;)?{
????????????final?Node?p?=?node.predecessor();
??????????//?如果是頭節(jié)點，再次嘗試
????????????if?(p?==?head?&&?tryAcquire(arg))?{
????????????????setHead(node);
????????????????p.next?=?null;?//?help?GC
????????????????failed?=?false;
????????????????return?interrupted;
????????????}
????????????if?(shouldParkAfterFailedAcquire(p,?node)?&&
????????????????parkAndCheckInterrupt())
????????????????interrupted?=?true;
????????}
????}?finally?{
????????if?(failed)
????????????cancelAcquire(node);
????}
}

/**
*?Checks?and?updates?status?for?a?node?that?failed?to?acquire.
*?Returns?true?if?thread?should?block.?This?is?the?main?signal
*?control?in?all?acquire?loops.??Requires?that?pred?==?node.prev.
*?如果獲取鎖失敗，檢查并且更新節(jié)點。如果需要被park阻塞，返回true。
*?在所有的循環(huán)邏輯中，這是主要的信號控制邏輯。
*
* pred：表示前驅(qū)節(jié)點
* node：表示當(dāng)前線程節(jié)點
*/
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.
?????????*/
?????????//?表明線程已經(jīng)準(zhǔn)備好被阻塞并等待之后被喚醒
????????return?true;
????if?(ws?>?0)?{
????????/*
?????????*?Predecessor?was?cancelled.?Skip?over?predecessors?and
?????????*?indicate?retry.
?????????*/
?????????//?若pred.waitStatus狀態(tài)位大于0，說明這個前驅(qū)點已經(jīng)取消了獲取鎖的操作，
?????????//?doWhile循環(huán)會遞歸刪除掉這些放棄獲取鎖的節(jié)點
????????do?{
????????????node.prev?=?pred?=?pred.prev;
????????}?while?(pred.waitStatus?>?0);
????????pred.next?=?node;
????}?else?{
????????/*
?????????*?節(jié)點剛創(chuàng)建的時候，status=0，邏輯會走到這里將自身狀態(tài)設(shè)置為signal
?????????*?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.
?????????*/
?????????//若狀態(tài)位不為Node.SIGNAL,且沒有取消操作，則會嘗試將前驅(qū)節(jié)點狀態(tài)位修改為Node.SIGNAL
????????//?表示將會喚醒后繼節(jié)點
????????compareAndSetWaitStatus(pred,?ws,?Node.SIGNAL);
????}
????return?false;
}

private?final?boolean?parkAndCheckInterrupt()?{
??//?阻塞線程
????LockSupport.park(this);
??//?線程繼續(xù)執(zhí)行
????return?Thread.interrupted();
}

//?ReentrantLock
public?void?unlock()?{
????sync.release(1);
}
//?AQS
public?final?boolean?release(int?arg)?{
??//?釋放鎖
????if?(tryRelease(arg))?{
????????Node?h?=?head;
????????if?(h?!=?null?&&?h.waitStatus?!=?0)
??????????//?喚醒后繼節(jié)點
????????????unparkSuccessor(h);
????????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;
}

//?喚醒后繼節(jié)點
private?void?unparkSuccessor(Node?node)?{
????/*
?????*?If?status?is?negative?(i.e.,?possibly?needing?signal)?try
?????*?to?clear?in?anticipation?of?signalling.??It?is?OK?if?this
?????*?fails?or?if?status?is?changed?by?waiting?thread.
?????*/
????int?ws?=?node.waitStatus;
????if?(ws?<?0)
????????compareAndSetWaitStatus(node,?ws,?0);

????/*
?????*?Thread?to?unpark?is?held?in?successor,?which?is?normally
?????*?just?the?next?node.??But?if?cancelled?or?apparently?null,
?????*?traverse?backwards?from?tail?to?find?the?actual
?????*?non-cancelled?successor.
?????*/
??//?拿到下一個節(jié)點
????Node?s?=?node.next;
??//要解除阻塞的線程在后繼節(jié)點中，通常只是下一個節(jié)點。但如果取消或明顯為空，則從尾部向前遍歷以找到實際未取消的繼任者。
????if?(s?==?null?||?s.waitStatus?>?0)?{
????????s?=?null;
????????for?(Node?t?=?tail;?t?!=?null?&&?t?!=?node;?t?=?t.prev)
????????????if?(t.waitStatus?<=?0)
????????????????s?=?t;
????}
????if?(s?!=?null)
??????//解鎖
????????LockSupport.unpark(s.thread);
}