一段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程序鎖住了哪個對象阿？“


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

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類的一個具體對象，也就是該線程自身作為對象鎖的。一共十個線程，每個線程持有自己 線程對象的那個對象鎖。這必然不能產生同步的效果。換句話說，如果要對這些線程進行同步，那么這些線程所持有的對象鎖應當是共享且唯一的！?

我們來看下面的例程：

?

Java代碼??

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個線程不再是爭先恐后的報數了，而是一個接一個的報數。

再來看下面的例程：

?

Java代碼??

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

?

?

• ??

  細心的讀者發現了：這段代碼沒有使用main方法中創建的String對象作為這10個線程的線程鎖。而是通過在run方法中調用本線 程中一個靜態的同步 方法abc而實現了線程的同步。我想看到這里，你們應該很困惑：這里synchronized靜態方法是用什么來做對象鎖的呢？
  
  
  
  我們知道，對于同步靜態方法，對象鎖就是該靜態放發所在的類的Class實例，由于在JVM中，所有被加載的類都有唯一的類對象，具體到本例，就是唯一的 ThreadTest3.class對象。不管我們創建了該類的多少實例，但是它的類實例仍然是一個！
  
  
  
  這樣我們就知道了：
  
  1、對于同步的方法或者代碼塊來說，必須獲得對象鎖才能夠進入同步方法或者代碼塊進行操作；
  
  
  2、如果采用method級別的同步，則對象鎖即為method所在的對象，如果是靜態方法，對象鎖即指method所在的
  Class對象(唯一)；
  
  
  3、對于代碼塊，對象鎖即指synchronized(abc)中的abc；
  
  
  4、因為第一種情況，對象鎖即為每一個線程對象，因此有多個，所以同步失效，第二種共用同一個對象鎖lock，因此同步生效，第三個因為是
  static因此對象鎖為ThreadTest3的class 對象，因此同步生效。
  
  如上述正確，則同步有兩種方式，同步塊和同步方法（為什么沒有wait和notify？這個我會在補充章節中做出闡述）
  
  如果是同步代碼塊，則對象鎖需要編程人員自己指定，一般有些代碼為synchronized(this)只有在單態模式才生效；
  （本類的實例有且只有一個）
  
  如果是同步方法，則分靜態和非靜態兩種?。
  
  靜態方法則一定會同步，非靜態方法需在單例模式才生效，推薦用靜態方法(不用擔心是否單例)。
  
  所以說，在Java多線程編程中，最常見的synchronized關鍵字實際上是依靠對象鎖的機制來實現線程同步的。
  我們似乎可以聽到synchronized在向我們說：“給我一把?鎖，我能創造一個規矩”。