Java並發包中Lock的實現原理
1. Lock 的簡介及使用
Lock是java 1.5中引入的線程同步工具，它主要用於多線程下共享資源的控制。本質上Lock僅僅是一個接口（位於源碼包中的java\util\concurrent\locks中），它包含以下方法
//嘗試獲取鎖，獲取成功則返回，否則阻塞當前線程 void lock(); //嘗試獲取鎖，線程在成功獲取鎖之前被中斷，則放棄獲取鎖，拋出異常 void lockInterruptibly() throws InterruptedException; //嘗試獲取鎖，獲取鎖成功則返回true，否則返回false boolean tryLock(); //嘗試獲取鎖，若在規定時間內獲取到鎖，則返回true，否則返回false，未獲取鎖之前被中斷，則拋出異常 boolean tryLock(long time, TimeUnit unit)throws InterruptedException; //釋放鎖 void unlock(); //返回當前鎖的條件變量，通過條件變量可以實現類似notify和wait的功能，一個鎖可以有多個條件變量 Condition newCondition();
Lock有三個實現類，一個是ReentrantLock,另兩個是ReentrantReadWriteLock類中的兩個靜態內部類ReadLock和WriteLock。
使用方法：多線程下訪問（互斥）共享資源時， 訪問前加鎖，訪問結束以後解鎖，解鎖的操作推薦放入finally塊中。
Lock l = ...; //根據不同的實現Lock接口類的構造函數得到一個鎖對象
l.lock(); //獲取鎖位於try塊的外面
try {
// access the resource protected by this lock
} finally {
l.unlock();
}
註意，加鎖位於對資源訪問的try塊的外部，特別是使用lockInterruptibly方法加鎖時就必須要這樣做，這為了防止線程在獲取鎖時被中斷，這時就不必（也不能）釋放鎖。
try {
l.lockInterruptibly();//獲取鎖失敗時不會執行finally塊中的unlock語句
try{
// access the resource protected by this lock
}finally{
l.unlock();
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
2. 實現Lock接口的基本思想
需要實現鎖的功能，兩個必備元素，一個是表示（鎖）狀態的變量（我們假設0表示沒有線程獲取鎖，1表示已有線程占有鎖），另一個是隊列，隊列中的節點表示因未能獲取鎖而阻塞的線程。為了解決多核處理器下多線程緩存不一致的問題，表示狀態的變量必須聲明為voaltile類型，並且對表示狀態的變量和隊列的某些操作要保證原子性和可見性。原子性和可見性的操作主要通過Atomic包中的方法實現。
線程獲取鎖的大致過程（這裏沒有考慮可重入和獲取鎖過程被中斷或超時的情況）
1. 讀取表示鎖狀態的變量
2. 如果表示狀態的變量的值為0，那麽當前線程嘗試將變量值設置為1（通過CAS操作完成），當多個線程同時將表示狀態的變量值由0設置成1時，僅一個線程能成功，其
它線程都會失敗
2.1 若成功，表示獲取了鎖，
2.1.1 如果該線程（或者說節點）已位於在隊列中，則將其出列（並將下一個節點則變成了隊列的頭節點）
2.1.2 如果該線程未入列，則不用對隊列進行維護
然後當前線程從lock方法中返回，對共享資源進行訪問。
2.2 若失敗，則當前線程將自身放入等待（鎖的）隊列中並阻塞自身，此時線程一直被阻塞在lock方法中，沒有從該方法中返回（被喚醒後仍然在lock方法中，並從下一條語句繼續執行，這裏又會回到第1步重新開始）。
3. 如果表示狀態的變量的值為1，那麽將當前線程放入等待隊列中，然後將自身阻塞（被喚醒後仍然在lock方法中，並從下一條語句繼續執行，這裏又會回到第1步重新開始）
註意: 喚醒並不表示線程能立刻運行，而是表示線程處於就緒狀態，僅僅是可以運行而已
線程釋放鎖的大致過程
1. 釋放鎖的線程將狀態變量的值從1設置為0，並喚醒等待（鎖）隊列中的隊首節點，釋放鎖的線程從就從unlock方法中返回，繼續執行線程後面的代碼
2. 被喚醒的線程（隊列中的隊首節點）和可能和未進入隊列並且準備獲取的線程競爭獲取鎖，重復獲取鎖的過程
註意：可能有多個線程同時競爭去獲取鎖，但是一次只能有一個線程去釋放鎖，隊列中的節點都需要它的前一個節點將其喚醒，例如有隊列A<-B-<C ，即由A釋放鎖時喚醒B，B釋放鎖時喚醒C
3. 公平鎖和非公平鎖
鎖可以分為公平鎖和不公平鎖，重入鎖和非重入鎖（關於重入鎖的介紹會在ReentrantLock源代碼分析中介紹），以上過程實際上是非公平鎖的獲取和釋放過程。
公平鎖嚴格按照先來後到的順去獲取鎖，而非公平鎖允許插隊獲取鎖。
公平鎖獲取鎖的過程上有些不同，在使用公平鎖時，某線程想要獲取鎖，不僅需要判斷當前表示狀態的變量的值是否為0，還要判斷隊列裏是否還有其他線程，若隊列中還有線程則說明當前線程需要排隊，進行入列操作，並將自身阻塞；若隊列為空，才能嘗試去獲取鎖。而對於非公平鎖，當表示狀態的變量的值是為0，就可以嘗試獲取鎖，不必理會隊列是否為空，這樣就實現了插隊獲取鎖的特點。通常來說非公平鎖的吞吐率比公平鎖要高，我們一般常用非公平鎖。
這裏需要解釋一點，什麽情況下才會出現，表示鎖的狀態的變量的值是為0而且隊列中仍有其它線程等待獲取鎖的情況。
假設有三個線程A、B、C。A線程為正在運行的線程並持有鎖，隊列中有一個C線程，位於隊首。現在A線程要釋放鎖，具體執行的過程操作可分為兩步：
1. 將表示鎖狀態的變量值由1變為0，
2. C線程被喚醒，這裏要明確兩點：
（1）C線程被喚醒並不代表C線程開始執行，C線程此時是處於就緒狀態，要等待操作系統的調度
（2）C線程目前還並未出列，C線程要進入運行狀態，並且通過競爭獲取到鎖以後才會出列。
如果C線程此時還沒有進入運行態，同時未在隊列中的B線程進行獲取鎖的操作，B就會發現雖然當前沒有線程持有鎖，但是隊列不為空（C線程仍然位於隊列中），要滿足先來後到的特點（B在C之後執行獲取鎖的操作），B線程就不能去嘗試獲取鎖，而是進行入列操作。
4. 實現Condition接口的基本思想
Condition 本質是一個接口，它包含如下方法
// 讓線程進入等通知待狀態void await() throws InterruptedException; void awaitUninterruptibly();//讓線程進入等待通知狀態，超時結束等待狀態，並拋出異常 long awaitNanos(long nanosTimeout) throws InterruptedException; boolean await(long time, TimeUnit unit) throws InterruptedException; boolean awaitUntil(Date deadline) throws InterruptedException; //將條件隊列中的一個線程，從等待通知狀態轉換為等待鎖狀態 void signal(); //將條件隊列中的所有線程，從等待通知阻塞狀態轉換為等待鎖阻塞狀態 void signalAll();
一個Condition實例的內部實際上維護了一個隊列，隊列中的節點表示由於（某些條件不滿足而）線程自身調用await方法阻塞的線程。Condition接口中有兩個重要的方法，即 await方法和 signal方法。線程調用這個方法之前該線程必須已經獲取了Condition實例所依附的鎖。這樣的原因有兩個，（1）對於await方法，它內部會執行釋放鎖的操作，所以使用前必須獲取鎖。（2）對於signal方法，是為了避免多個線程同時調用同一個Condition實例的singal方法時引起的（隊列）出列競爭。下面是這兩個方法的執行流程。
await方法：
1. 入列到條件隊列（註意這裏不是等待鎖的隊列）
2. 釋放鎖
3. 阻塞自身線程
------------被喚醒後執行-------------
4. 嘗試去獲取鎖（執行到這裏時線程已不在條件隊列中，而是位於等待（鎖的）隊列中，參見signal方法）
4.1 成功，從await方法中返回，執行線程後面的代碼
4.2 失敗，阻塞自己（等待前一個節點釋放鎖時將它喚醒）
註意：await方法時自身線程調用的，線程在await方法中阻塞，並沒有從await方法中返回，當喚醒後繼續執行await方法中後面的代碼（也就是獲取鎖的代碼）。可以看出await方法釋放了鎖，又嘗試獲得鎖。當獲取鎖不成功的時候當前線程仍然會阻塞到await方法中，等待前一個節點釋放鎖後再將其喚醒。
signal方法：
1. 將條件隊列的隊首節點取出，放入等待鎖隊列的隊尾
2. 喚醒該節點對應的線程
註意：signal是由其它線程調用
Lock和Condition的使用例程
下面這個例子，就是利用lock和condition實現B線程先打印一句信息後，然後A線程打印兩句信息（不能中斷），交替十次後結束
public class ConditionDemo {
volatile int key = 0;
Lock l = new ReentrantLock();
Condition c = l.newCondition();
public static void main(String[] args){
ConditionDemo demo = new ConditionDemo();
new Thread(demo.new A()).start();
new Thread(demo.new B()).start();
}
class A implements Runnable{
@Override
public void run() {
int i = 10;
while(i > 0){
l.lock();
try{
if(key == 1){
System.out.println("A is Running");
System.out.println("A is Running");
i--;
key = 0;
c.signal();
}else{
c.awaitUninterruptibly();
}
}
finally{
l.unlock();
}
}
}
}
class B implements Runnable{
@Override
public void run() {
int i = 10;
while(i > 0){
l.lock();
try{
if(key == 0){
System.out.println("B is Running");
i--;
key = 1;
c.signal();
}else{
c.awaitUninterruptibly();
}
}
finally{
l.unlock();
}
}
}
}
}
5. Lock與synchronized的區別
1. Lock的加鎖和解鎖都是由java代碼配合native方法（調用操作系統的相關方法）實現的，而synchronize的加鎖和解鎖的過程是由JVM管理的
2. 當一個線程使用synchronize獲取鎖時，若鎖被其他線程占用著，那麽當前只能被阻塞，直到成功獲取鎖。而Lock則提供超時鎖和可中斷等更加靈活的方式，在未能獲取鎖的 條件下提供一種退出的機制。
3. 一個鎖內部可以有多個Condition實例，即有多路條件隊列，而synchronize只有一路條件隊列；同樣Condition也提供靈活的阻塞方式，在未獲得通知之前可以通過中斷線程以 及設置等待時限等方式退出條件隊列。
4. synchronize對線程的同步僅提供獨占模式，而Lock即可以提供獨占模式，也可以提供共享模式
Java並發包中Lock的實現原理