java鎖機制

一段synchronized的程式碼被一個執行緒執行之前，他要先拿到執行這段程式碼的許可權，在java裡邊就是拿到某個同步物件的鎖（一個物件只有一把鎖）； 如果這個時候同步物件的鎖被其他執行緒拿走了，他（這個執行緒）就只能等了（執行緒阻塞在鎖池等待佇列中）。 取到鎖後，他就開始執行同步程式碼(被synchronized修飾的程式碼）；執行緒執行完同步程式碼後馬上就把鎖還給同步物件，其他在鎖池中等待的某個執行緒就可以拿到鎖執行同步程式碼了。這樣就保證了同步程式碼在統一時刻只有一個執行緒在執行。

眾所周知，在Java多執行緒程式設計中，一個非常重要的方面就是執行緒的同步問題。
關於執行緒的同步，一般有以下解決方法：

1. 在需要同步的方法的方法簽名中加入synchronized關鍵字。

2. 使用synchronized塊對需要進行同步的程式碼段進行同步。

3. 使用JDK 5中提供的java.util.concurrent.lock包中的Lock物件。

另外，為了解決多個執行緒對同一變數進行訪問時可能發生的安全性問題，我們不僅可以採用同步機制，更可以通過JDK 1.2中加入的ThreadLocal來保證更好的併發性。

本篇中，將詳細的討論Java多執行緒同步機制，並對ThreadLocal做出探討。

大致的目錄結構如下：

一、執行緒的先來後到——問題的提出：為什麼要有多執行緒同步？Java多執行緒同步的機制是什麼？
二、給我一把鎖，我能創造一個規矩——傳統的多執行緒同步程式設計方法有哪些？他們有何異同？
三、Lock來了，大家都讓開—— Java併發框架中的Lock詳解。
四、你有我有全都有—— ThreadLocal如何解決併發安全性？
五、總結——Java執行緒安全的幾種方法對比。


一、執行緒的先來後到

我們來舉一個Dirty的例子：某餐廳的衛生間很小，幾乎只能容納一個人如廁。為了保證不受干擾，如廁的人進入衛生間，就要鎖上房門。我們可以把衛生間想 象成是共享的資源，而眾多需要如廁的人可以被視作多個執行緒。假如衛生間當前有人佔用，那麼其他人必須等待，直到這個人如廁完畢，開啟房門走出來為止。這就 好比多個執行緒共享一個資源的時候，是一定要分出先來後到的。

有人說：那如果我沒有這道門會怎樣呢？讓兩個執行緒相互競爭，誰搶先了，誰就可以先幹活，這樣多好阿？但是我們知道：如果廁所沒有門的話，如廁的人一起湧向 廁所，那麼必然會發生爭執，正常的如廁步驟就會被打亂，很有可能會發生意想不到的結果，例如某些人可能只好被迫在不正確的地方施肥……

正是因為有這道門，任何一個單獨進入如廁的人都可以順利的完成他們的如廁過程，而不會被干擾，甚至發生以外的結果。這就是說，如廁的時候要講究先來後到。


那麼在Java 多執行緒程式當中，當多個執行緒競爭同一個資源的時候，如何能夠保證他們不會產生“打架”的情況呢？有人說是使用同步機制。沒錯，像上面這個例子，就是典型的 同步案例，一旦第一位開始如廁，則第二位必須等待第一位結束，才能開始他的如廁過程。一個執行緒，一旦進入某一過程，必須等待正常的返回，並退出這一過程， 下一個執行緒才能開始這個過程。這裡，最關鍵的就是衛生間的門。其實，衛生間的門擔任的是資源鎖的角色，只要如廁的人鎖上門，就相當於獲得了這個鎖，而當他 開啟鎖出來以後，就相當於釋放了這個鎖。

也就是說，多執行緒的執行緒同步機制實際上是靠鎖的概念來控制的。那麼在Java程式當中，鎖是如何體現的呢？


讓我們從JVM的角度來看看鎖這個概念：

在Java程式執行時環境中，JVM需要對兩類執行緒共享的資料進行協調：
1）儲存在堆中的例項變數
2）儲存在方法區中的類變數

這兩類資料是被所有執行緒共享的。
（程式不需要協調儲存在Java 棧當中的資料。因為這些資料是屬於擁有該棧的執行緒所私有的。）

在java虛擬機器中，每個物件和類在邏輯上都是和一個監視器相關聯的。
對於物件來說，相關聯的監視器保護物件的例項變數。

對於類來說，監視器保護類的類變數。

（如果一個物件沒有例項變數，或者一個類沒有變數，相關聯的監視器就什麼也不監視。）
為了實現監視器的排他性監視能力，java虛擬機器為每一個物件和類都關聯一個鎖。代表任何時候只允許一個執行緒擁有的特權。執行緒訪問例項變數或者類變數不需鎖。

但是如果執行緒獲取了鎖，那麼在它釋放這個鎖之前，就沒有其他執行緒可以獲取同樣資料的鎖了。（鎖住一個物件就是獲取物件相關聯的監視器）

類鎖實際上用物件鎖來實現。當虛擬機器裝載一個class檔案的時候，它就會建立一個java.lang.Class類的例項。當鎖住一個物件的時候，實際上鎖住的是那個類的Class物件。

一個執行緒可以多次對同一個物件上鎖。對於每一個物件，java虛擬機器維護一個加鎖計數器，執行緒每獲得一次該物件，計數器就加1，每釋放一次，計數器就減 1，當計數器值為0時，鎖就被完全釋放了。

java程式設計人員不需要自己動手加鎖，物件鎖是java虛擬機器內部使用的。

在java程式中，只需要使用synchronized塊或者synchronized方法就可以標誌一個監視區域。當每次進入一個監視區域時，java 虛擬機器都會自動鎖上物件或者類。

看到這裡，我想你們一定都疲勞了吧？o(∩_∩)o...哈哈。讓我們休息一下，但是在這之前，請你們一定要記著：
當一個有限的資源被多個執行緒共享的時候，為了保證對共享資源的互斥訪問，我們一定要給他們排出一個先來後到。而要做到這一點，物件鎖在這裡起著非常重要的作用。

在上一篇中，我們講到了多執行緒是如何處理共享資源的，以及保證他們對資源進行互斥訪問所依賴的重要機制：物件鎖。



本篇中，我們來看一看傳統的同步實現方式以及這背後的原理。



很多人都知道，在Java多執行緒程式設計中，有一個重要的關鍵字，synchronized。但是很多人看到這個東西會感到困惑：“都說同步機制是通過物件鎖來實現的，但是這麼一個關鍵字，我也看不出來Java程式鎖住了哪個物件阿？“


沒錯，我一開始也是對這個問題感到困惑和不解。不過還好，我們有下面的這個例程：

1. public class ThreadTest extends Thread {   
2.     private int threadNo;   
3.     public ThreadTest(int threadNo) {   
4.         this.threadNo = threadNo;   
5.     }   
6.     public static void main(String[] args) throws Exception {   
7.         for (int i = 1; i < 10; i++) {   
8.            new ThreadTest(i).start();   
9.             Thread.sleep(1);   
10.         }   
11.      }   
12.     
13.     @Override  
14.      public synchronized void run() {   
15.         for (int i = 1; i < 10000; i++) {   
16.             System.out.println("No." + threadNo + ":" + i);   
17.         }   
18.      }   
19.  }   

      這個程式其實就是讓10個執行緒在控制檯上數數，從1數到9999。理想情況下，我們希望看到一個執行緒數完，然後才是另一個執行緒開始數數。但是這個程式的執行過程告訴我們，這些執行緒還是亂糟糟的在那裡搶著報數，絲毫沒有任何規矩可言。
     但是細心的讀者注意到：run方法還是加了一個synchronized關鍵字的，按道理說，這些執行緒應該可以一個接一個的執行這個run方法才對阿。
     但是通過上一篇中，我們提到的，對於一個成員方法加synchronized關鍵字，這實際上是以這個成員方法所在的物件本身作為物件鎖。在本例中，就是 以ThreadTest類的一個具體物件，也就是該執行緒自身作為物件鎖的。一共十個執行緒，每個執行緒持有自己 執行緒物件的那個物件鎖。這必然不能產生同步的效果。換句話說，如果要對這些執行緒進行同步，那麼這些執行緒所持有的物件鎖應當是共享且唯一的！

我們來看下面的例程：

1. public class ThreadTest2 extends Thread {   
2.  private int threadNo; private String lock;   
3.  public ThreadTest2(int threadNo, String lock) {   
4.   this.threadNo = threadNo;   
5.      this.lock = lock;   }   
6. public static void main(String[] args) throws Exception {   
7.    String lock = new String("lock");   
8.      for (int i = 1; i < 10; i++) {     
9.   new ThreadTest2(i, lock).start();   
10.       Thread.sleep(1);   
11.      }   
12.   }     
13. public void run() {     
14.  synchronized (lock) {   
15.       for (int i = 1; i < 10000; i++) {   
16.        System.out.println("No." + threadNo + ":" + i);   
17.     }      
18.  }     
19.  }   
20.  }  

        我們注意到，該程式通過在main方法啟動10個執行緒之前，建立了一個String型別的物件。並通過ThreadTest2的建構函式，將這個物件賦值 給每一個ThreadTest2執行緒物件中的私有變數lock。根據Java方法的傳值特點，我們知道，這些執行緒的lock變數實際上指向的是堆記憶體中的 同一個區域，即存放main函式中的lock變數的區域。
        程式將原來run方法前的synchronized關鍵字去掉，換用了run方法中的一個synchronized塊來實現。這個同步塊的物件鎖，就是 main方法中建立的那個String物件。換句話說，他們指向的是同一個String型別的物件，物件鎖是共享且唯一的！

於是，我們看到了預期的效果：10個執行緒不再是爭先恐後的報數了，而是一個接一個的報數。

再來看下面的例程：

1 public class ThreadTest3 extends Thread {