[轉載]Java synchronized詳解

在編寫一個類時，若是該類中的代碼可能運行於多線程環境下，那麼就要考慮同步的問題。在Java中內置了語言級的同步原語－－synchronized，這也大大簡化了Java中多線程同步的使用。咱們首先編寫一個很是簡單的多線程的程序，是模擬銀行中的多個線程同時對同一個儲蓄帳戶進行存款、取款操做的。

在程序中咱們使用了一個簡化版本的Account類，表明了一個銀行帳戶的信息。在主程序中咱們首先生成了1000個線程，而後啓動它們，每個線程都對John的帳戶進行存100元，而後立刻又取出100元。這樣，對於John的帳戶來講，最終帳戶的餘額應該是仍是1000元纔對。然而運行的結果卻超出咱們的想像，首先來看看咱們的演示代碼：

class Account {
String name;
float amount;


public Account(String name, float amount) {
this.name = name;
this.amount = amount;
}

public void deposit(float amt) {
float tmp = amount;
tmp += amt;

try {
Thread.sleep(100);//模擬其它處理所須要的時間，好比刷新數據庫等
} catch (InterruptedException e) {
// ignore
}

amount = tmp;
}

public void withdraw(float amt) {
float tmp = amount;
tmp -= amt;

try {
Thread.sleep(100);//模擬其它處理所須要的時間，好比刷新數據庫等
} catch (InterruptedException e) {
// ignore
}

amount = tmp;
}

public float getBalance() {
return amount;
}
}

 

public class AccountTest{
private static int NUM_OF_THREAD = 1000;
static Thread[] threads = new Thread[NUM_OF_THREAD];

public static void main(String[] args){
final Account acc = new Account("John", 1000.0f);
for (int i = 0; i< NUM_OF_THREAD; i++) {
threads[i] = new Thread(new Runnable() {
public void run() {
acc.deposit(100.0f);
acc.withdraw(100.0f);
}
});
threads[i].start();
}

for (int i=0; i<NUM_OF_THREAD; i++){
try {
threads[i].join(); //等待全部線程運行結束
} catch (InterruptedException e) {
// ignore
}
}
System.out.println("Finally, John's balance is:" + acc.getBalance());
}

}

注意，上面在Account的deposit和withdraw方法中之因此要把對amount的運算使用一個臨時變量首先存儲，sleep一段時間，而後，再賦值給amount，是爲了模擬真實運行時的狀況。由於在真實系統中，帳戶信息確定是存儲在持久媒介中，好比RDBMS中，此處的睡眠的時間至關於比較耗時的數據庫操做，最後把臨時變量tmp的值賦值給amount至關於把amount的改動寫入數據庫中。運行AccountTest，結果以下（每一次結果都會不一樣）：

E:\java\exer\bin>java AccountTest
Finally, John's balance is:3900.0

E:\java\exer\bin>java AccountTest
Finally, John's balance is:4900.0

E:\java\exer\bin>java AccountTest
Finally, John's balance is:4700.0

E:\java\exer\bin>java AccountTest
Finally, John's balance is:3900.0

E:\java\exer\bin>java AccountTest
Finally, John's balance is:3900.0

E:\java\exer\bin>java AccountTest
Finally, John's balance is:5200.0

爲何會出現這樣的問題？這就是多線程中的同步的問題。在咱們的程序中，Account中的amount會同時被多個線程所訪問，這就是一個競爭資源，一般稱做競態條件。對於這樣的多個線程共享的資源咱們必須進行同步，以免一個線程的改動被另外一個線程所覆蓋。在咱們這個程序中，Account中的amount是一個競態條件，因此全部對amount的修改訪問都要進行同步，咱們將deposit()和withdraw()方法進行同步，修改成：

 

public synchronized void deposit(float amt) {
float tmp = amount;
tmp += amt;

try {
Thread.sleep(1);//模擬其它處理所須要的時間，好比刷新數據庫等
} catch (InterruptedException e) {
// ignore
}

amount = tmp;
}

public synchronized void withdraw(float amt) {
float tmp = amount;
tmp -= amt;

try {
Thread.sleep(1);//模擬其它處理所須要的時間，好比刷新數據庫等
} catch (InterruptedException e) {
// ignore
}

amount = tmp;
}

 

此時，再運行，咱們就可以獲得正確的結果了。Account中的getBalance()也訪問了amount，爲何不對getBalance()同步呢？由於getBalance()並不會修改amount的值，因此，同時多個線程對它訪問不會形成數據的混亂。

 

同步加鎖的是對象，而不是代碼。

所以，若是你的類中有一個同步方法，這個方法能夠被兩個不一樣的線程同時執行，只要每一個線程本身建立一個的該類的實例便可。

 

　　參考下面的代碼：

class Foo extends Thread
{
　private int val;
　public Foo(int v)
　{
　　val = v;
　}
　public synchronized void printVal(int v)
　{
　　while(true)
　　　System.out.println(v);
　}
　public void run()
　{
　　printVal(val);
　}
}
class SyncTest
{
　public static void main(String args[])
　{
　　Foo f1 = new Foo(1);
　　f1.start();
　　Foo f2 = new Foo(3);
　　f2.start();
　}
}

　　運行SyncTest產生的輸出是1和3交叉的。若是printVal是斷面，你看到的輸出只能是1或者只能是3而不能是二者同時出現。程序運行的結果證實兩個線程都在併發的執行printVal方法，即便該方法是同步的而且因爲是一個無限循環而沒有終止。

類的同步：

要實現真正的斷面，你必須同步一個全局對象或者對類進行同步。下面的代碼給出了一個這樣的範例。

class Foo extends Thread
{
　private int val;
　public Foo(int v)
　{
　　val = v;
　}
　public void printVal(int v)
　{
　　synchronized(Foo.class) {
　　　while(true)
　　　　System.out.println(v);
　　}
　}
　public void run()
　{
　　printVal(val);
　}
}

　　上面的類再也不對個別的類實例同步而是對類進行同步。對於類Foo而言，它只有惟一的類定義，兩個線程在相同的鎖上同步，所以只有一個線程能夠執行printVal方法。

　　這個代碼也能夠經過對公共對象加鎖。例如給Foo添加一個靜態成員。兩個方法均可以同步這個對象而達到線程安全。

面筆者給出一個參考實現，給出同步公共對象的兩種一般方法：

　　一、

class Foo extends Thread
{
　private int val;
　private static Object lock=new Object();
　public Foo(int v)
　{
　　val = v;
　}
　public void printVal(int v)
　{
　　synchronized(lock) {
　　　while(true)
　　　　System.out.println(v);
　　}
　}
　public void run()
　{
　　printVal(val);
　}
}

　　上面的這個例子比原文給出的例子要好一些，由於原文中的加鎖是針對類定義的，一個類只能有一個類定義，而同步的通常原理是應該儘可能減少同步的粒度以到達更好的性能。筆者給出的範例的同步粒度比原文的要小。

　　二、

class Foo extends Thread
{
　private String name;
　private String val;
　public Foo(String name,String v)
　{
　　this.name=name;
　　val = v;
　}
　public void printVal()
　{
　　synchronized(val) {
　　　while(true) System.out.println(name+val);
　　}
　}
　public void run()
　{
　　printVal();
　}
}
public class SyncMethodTest
{
　public static void main(String args[])
　{
　　Foo f1 = new Foo("Foo 1:","printVal");
　　f1.start();
　　Foo f2 = new Foo("Foo 2:","printVal");
　　f2.start();
　}
}

　　上面這個代碼須要進行一些額外的說明，由於JVM有一種優化機制，由於String類型的對象是不可變的，所以當你使用""的形式引用字符串時，若是JVM發現內存已經有一個這樣的對象，那麼它就使用那個對象而再也不生成一個新的String對象，這樣是爲了減少內存的使用。

　　上面的main方法其實等同於：

public static void main(String args[])
{
　String value="printVal";
　Foo f1 = new Foo("Foo 1:",value);
　f1.start();
　Foo f2 = new Foo("Foo 2:",value);
　f2.start();
}

 

總結：

一、synchronized關鍵字的做用域有二種：
1）是某個對象實例內，synchronized aMethod(){}能夠防止多個線程同時訪問這個對象的synchronized方法（若是一個對象有多個synchronized方法，只要一個線程訪問了其中的一個synchronized方法，其它線程不能同時訪問這個對象中任何一個synchronized方法）。這時，不一樣的對象實例的synchronized方法是不相干擾的。也就是說，其它線程照樣能夠同時訪問相同類的另外一個對象實例中的synchronized方法；
2）是某個類的範圍，synchronized static aStaticMethod{}防止多個線程同時訪問這個類中的synchronized static 方法。它能夠對類的全部對象實例起做用。

二、除了方法前用synchronized關鍵字，synchronized關鍵字還能夠用於方法中的某個區塊中，表示只對這個區塊的資源實行互斥訪問。用法是: synchronized(this){/*區塊*/}，它的做用域是當前對象；

三、synchronized關鍵字是不能繼承的，也就是說，基類的方法synchronized f(){} 在繼承類中並不自動是synchronized f(){}，而是變成了f(){}。繼承類須要你顯式的指定它的某個方法爲synchronized方法；

Java語言的關鍵字，當它用來修飾一個方法或者一個代碼塊的時候，可以保證在同一時刻最多隻有一個線程執行該段代碼。

1、當兩個併發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程獲得執行。另外一個線程必須等待當前線程執行完這個代碼塊之後才能執行該代碼塊。

2、然而，當一個線程訪問object的一個synchronized(this)同步代碼塊時，另外一個線程仍然能夠訪問該object中的非synchronized(this)同步代碼塊。

3、尤爲關鍵的是，當一個線程訪問object的一個synchronized(this)同步代碼塊時，其餘線程對object中全部其它synchronized(this)同步代碼塊的訪問將被阻塞。

4、第三個例子一樣適用其它同步代碼塊。也就是說，當一個線程訪問object的一個synchronized(this)同步代碼塊時，它就得到了這個object的對象鎖。結果，其它線程對該object對象全部同步代碼部分的訪問都被暫時阻塞。

5、以上規則對其它對象鎖一樣適用.

 

第二篇：

synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。
1. synchronized 方法：經過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：
public synchronized void accessVal(int newVal);
synchronized 方法控制對類成員變量的訪問：每一個類實例對應一把鎖，每一個 synchronized 方法都必須得到調用該方法的類實例的鎖方能

執行，不然所屬線程阻塞，方法一旦執行，就獨佔該鎖，直到從該方法返回時纔將鎖釋放，此後被阻塞的線程方能得到該鎖，從新進入可執行

狀態。這種機制確保了同一時刻對於每個類實例，其全部聲明爲 synchronized 的成員函數中至多隻有一個處於可執行狀態（由於至多隻有

一個可以得到該類實例對應的鎖），從而有效避免了類成員變量的訪問衝突（只要全部可能訪問類成員變量的方法均被聲明爲 synchronized）

。
在 Java 中，不光是類實例，每個類也對應一把鎖，這樣咱們也可將類的靜態成員函數聲明爲 synchronized ，以控制其對類的靜態成

員變量的訪問。
synchronized 方法的缺陷：若將一個大的方法聲明爲synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明爲

synchronized ，因爲在線程的整個生命期內它一直在運行，所以將致使它對本類任何 synchronized 方法的調用都永遠不會成功。固然咱們可

以經過將訪問類成員變量的代碼放到專門的方法中，將其聲明爲 synchronized ，並在主方法中調用來解決這一問題，可是 Java 爲咱們提供

了更好的解決辦法，那就是 synchronized 塊。
2. synchronized 塊：經過 synchronized關鍵字來聲明synchronized 塊。語法以下：
synchronized(syncObject) {
//容許訪問控制的代碼
}
synchronized 塊是這樣一個代碼塊，其中的代碼必須得到對象 syncObject （如前所述，能夠是類實例或類）的鎖方能執行，具體機

制同前所述。因爲能夠針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。
對synchronized(this)的一些理解
1、當兩個併發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程獲得執行。另外一個線

程必須等待當前線程執行完這個代碼塊之後才能執行該代碼塊。
2、然而，當一個線程訪問object的一個synchronized(this)同步代碼塊時，另外一個線程仍然能夠訪問該object中的非synchronized

(this)同步代碼塊。
3、尤爲關鍵的是，當一個線程訪問object的一個synchronized(this)同步代碼塊時，其餘線程對object中全部其它synchronized(this)

同步代碼塊的訪問將被阻塞。
4、第三個例子一樣適用其它同步代碼塊。也就是說，當一個線程訪問object的一個synchronized(this)同步代碼塊時，它就得到了這個

object的對象鎖。結果，其它線程對該object對象全部同步代碼部分的訪問都被暫時阻塞。
5、以上規則對其它對象鎖一樣適用

第三篇：

打個比方：一個object就像一個大房子，大門永遠打開。房子裏有 不少房間（也就是方法）。

這些房間有上鎖的（synchronized方法）， 和不上鎖之分（普通方法）。房門口放着一把鑰匙（key），這把鑰匙能夠打開全部上鎖的房間。

另外我把全部想調用該對象方法的線程比喻成想進入這房子某個 房間的人。全部的東西就這麼多了，下面咱們看看這些東西之間如何做用的。

在此咱們先來明確一下咱們的前提條件。該對象至少有一個synchronized方法，不然這個key還有啥意義。固然也就不會有咱們的這個主題了。

一我的想進入某間上了鎖的房間，他來到房子門口，看見鑰匙在那兒（說明暫時尚未其餘人要使用上鎖的 房間）。因而他走上去拿到了鑰匙

，而且按照本身 的計劃使用那些房間。注意一點，他每次使用完一次上鎖的房間後會立刻把鑰匙還回去。即便他要連續使用兩間上鎖的房間，

中間他也要把鑰匙還回去，再取回來。

所以，普通狀況下鑰匙的使用原則是：「隨用隨借，用完即還。」

這時其餘人能夠不受限制的使用那些不上鎖的房間，一我的用一間能夠，兩我的用一間也能夠，沒限制。可是若是當某我的想要進入上鎖的房

間，他就要跑到大門口去看看了。有鑰匙固然拿了就走，沒有的話，就只能等了。

要是不少人在等這把鑰匙，等鑰匙還回來之後，誰會優先獲得鑰匙？Not guaranteed。象前面例子裏那個想連續使用兩個上鎖房間的傢伙，他

中間還鑰匙的時候若是還有其餘人在等鑰匙，那麼沒有任何保證這傢伙能再次拿到。 （JAVA規範在不少地方都明確說明不保證，象

Thread.sleep()休息後多久會返回運行，相同優先權的線程那個首先被執行，當要訪問對象的鎖被 釋放後處於等待池的多個線程哪一個會優先得

到，等等。我想最終的決定權是在JVM，之因此不保證，就是由於JVM在作出上述決定的時候，毫不是簡簡單單根據 一個條件來作出判斷，而是

根據不少條。而因爲判斷條件太多，若是說出來可能會影響JAVA的推廣，也多是由於知識產權保護的緣由吧。SUN給了個不保證 就混過去了

。無可厚非。但我相信這些不肯定，並不是徹底不肯定。由於計算機這東西自己就是按指令運行的。即便看起來很隨機的現象，其實都是有規律

可尋。學過 計算機的都知道，計算機裏隨機數的學名是僞隨機數，是人運用必定的方法寫出來的，看上去隨機罷了。另外，或許是由於要想弄

的肯定太費事，也沒多大意義，所 以不肯定就不肯定了吧。）

再來看看同步代碼塊。和同步方法有小小的不一樣。

1.從尺寸上講，同步代碼塊比同步方法小。你能夠把同步代碼塊當作是沒上鎖房間裏的一塊用帶鎖的屏風隔開的空間。

2.同步代碼塊還能夠人爲的指定得到某個其它對象的key。就像是指定用哪一把鑰匙才能開這個屏風的鎖，你能夠用本房的鑰匙；你也能夠指定

用另外一個房子的鑰匙才能開，這樣的話，你要跑到另外一棟房子那兒把那個鑰匙拿來，並用那個房子的鑰匙來打開這個房子的帶鎖的屏風。

記住你得到的那另外一棟房子的鑰匙，並不影響其餘人進入那棟房子沒有鎖的房間。

爲何要使用同步代碼塊呢？我想應該是這樣的：首先對程序來說同步的部分很影響運行效率，而一個方法一般是先建立一些局部變

量，再對這些變量作一些 操做，如運算，顯示等等；而同步所覆蓋的代碼越多，對效率的影響就越嚴重。所以咱們一般儘可能縮小其影響範圍。

如何作？同步代碼塊。咱們只把一個方法中該同 步的地方同步，好比運算。

另外，同步代碼塊能夠指定鑰匙這一特色有個額外的好處，是能夠在必定時期內霸佔某個對象的key。還記得前面說過普通狀況下鑰

匙的使用原則嗎。如今不是普通狀況了。你所取得的那把鑰匙不是永遠不還，而是在退出同步代碼塊時才還。

還用前面那個想連續用兩個上鎖房間的傢伙打比方。怎樣才能在用完一間之後，繼續使用另外一間呢。用同步代碼塊吧。先建立另外

一個線程，作一個同步代碼 塊，把那個代碼塊的鎖指向這個房子的鑰匙。而後啓動那個線程。只要你能在進入那個代碼塊時抓到這房子的鑰匙

，你就能夠一直保留到退出那個代碼塊。也就是說 你甚至能夠對本房內全部上鎖的房間遍歷，甚至再sleep(10*60*1000)，而房門口卻還有

1000個線程在等這把鑰匙呢。很過癮吧。

在此對sleep()方法和鑰匙的關聯性講一下。一個線程在拿到key後，且沒有完成同步的內容時，若是被強制sleep()了，那key還一

直在 它那兒。直到它再次運行，作完全部同步內容，纔會歸還key。記住，那傢伙只是幹活幹累了，去休息一下，他並沒幹完他要乾的事。爲

了避免別人進入那個房間 把裏面搞的一團糟，即便在睡覺的時候他也要把那惟一的鑰匙戴在身上。

最後，也許有人會問，爲何要一把鑰匙通開，而不是一個鑰匙一個門呢？我想這純粹是由於複雜性問題。一個鑰匙一個門固然更

安全，可是會牽扯好多問題。鑰匙 的產生，保管，得到，歸還等等。其複雜性有可能隨同步方法的增長呈幾何級數增長，嚴重影響效率。這也

算是一個權衡的問題吧。爲了增長一點點安全性，致使效 率大大下降，是多麼不可取啊。

synchronized的一個簡單例子

public class TextThread {

public static void main(String[] args) {
TxtThread tt = new TxtThread();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
}
}

class TxtThread implements Runnable {
int num = 100;
String str = new String();

public void run() {
synchronized (str) {
while (num > 0) {

try {
Thread.sleep(1);
} catch (Exception e) {
e.getMessage();
}
System.out.println(Thread.currentThread().getName()
+ "this is " + num--);
}
}
}
}

上面的例子中爲了製造一個時間差,也就是出錯的機會,使用了Thread.sleep(10)

Java對多線程的支持與同步機制深受你們的喜好，彷佛看起來使用了synchronized關鍵字就能夠輕鬆地解決多線程共享數據同步問題。到底如

何？――還得對synchronized關鍵字的做用進行深刻了解纔可定論。

總的說來，synchronized關鍵字能夠做爲函數的修飾符，也可做爲函數內的語句，也就是平時說的同步方法和同步語句塊。若是再細的分類，

synchronized可做用於instance變量、object reference（對象引用）、static函數和class literals(類名稱字面常量)身上。

在進一步闡述以前，咱們須要明確幾點：

A．不管synchronized關鍵字加在方法上仍是對象上，它取得的鎖都是對象，而不是把一段代碼或函數看成鎖――並且同步方法極可能還會被其

他線程的對象訪問。

B．每一個對象只有一個鎖（lock）與之相關聯。

C．實現同步是要很大的系統開銷做爲代價的，甚至可能形成死鎖，因此儘可能避免無謂的同步控制。

接着來討論synchronized用到不一樣地方對代碼產生的影響：

假設P一、P2是同一個類的不一樣對象，這個類中定義瞭如下幾種狀況的同步塊或同步方法，P一、P2就均可以調用它們。

1． 把synchronized看成函數修飾符時，示例代碼以下：

Public synchronized void methodAAA()

{

//….

}

這也就是同步方法，那這時synchronized鎖定的是哪一個對象呢？它鎖定的是調用這個同步方法對象。也就是說，當一個對象P1在不一樣的線程中

執行這個同步方法時，它們之間會造成互斥，達到同步的效果。可是這個對象所屬的Class所產生的另外一對象P2卻能夠任意調用這個被加了

synchronized關鍵字的方法。

上邊的示例代碼等同於以下代碼：

public void methodAAA()

{

synchronized (this) // (1)

{

//…..

}

}

(1)處的this指的是什麼呢？它指的就是調用這個方法的對象，如P1。可見同步方法實質是將synchronized做用於object reference。――那個

拿到了P1對象鎖的線程，才能夠調用P1的同步方法，而對P2而言，P1這個鎖與它絕不相干，程序也可能在這種情形下襬脫同步機制的控制，造

成數據混亂：（

2．同步塊，示例代碼以下：

public void method3(SomeObject so)

{

synchronized(so)

{
//…..
}

}

這時，鎖就是so這個對象，誰拿到這個鎖誰就能夠運行它所控制的那段代碼。當有一個明確的對象做爲鎖時，就能夠這樣寫程序，但當沒有明

確的對象做爲鎖，只是想讓一段代碼同步時，能夠建立一個特殊的instance變量（它得是一個對象）來充當鎖：

class Foo implements Runnable

{

private byte[] lock = new byte[0]; // 特殊的instance變量

Public void methodA()
{

synchronized(lock) { //… }

}

//…..

}

注：零長度的byte數組對象建立起來將比任何對象都經濟――查看編譯後的字節碼：生成零長度的byte[]對象只需3條操做碼，而Object lock

= new Object()則須要7行操做碼。

3．將synchronized做用於static 函數，示例代碼以下：

Class Foo
{

public synchronized static void methodAAA() // 同步的static 函數
{
//….
}

public void methodBBB()
{

synchronized(Foo.class) // class literal(類名稱字面常量)

}
}

代碼中的methodBBB()方法是把class literal做爲鎖的狀況，它和同步的static函數產生的效果是同樣的，取得的鎖很特別，是當前調用這

個方法的對象所屬的類（Class，而再也不是由這個Class產生的某個具體對象了）。

記得在《Effective Java》一書中看到過將 Foo.class和 P1.getClass()用於做同步鎖還不同，不能用P1.getClass()來達到鎖這個Class的

目的。P1指的是由Foo類產生的對象。

能夠推斷：若是一個類中定義了一個synchronized的static函數A，也定義了一個synchronized 的instance函數B，那麼這個類的同一對象Obj

在多線程中分別訪問A和B兩個方法時，不會構成同步，由於它們的鎖都不同。A方法的鎖是Obj這個對象，而B的鎖是Obj所屬的那個Class。

小結以下：

搞清楚synchronized鎖定的是哪一個對象，就能幫助咱們設計更安全的多線程程序。

還有一些技巧可讓咱們對共享資源的同步訪問更加安全：

1． 定義private 的instance變量+它的 get方法，而不要定義public/protected的instance變量。若是將變量定義爲public，對象在外界能夠

繞過同步方法的控制而直接取得它，並改動它。這也是JavaBean的標準實現方式之一。

2． 若是instance變量是一個對象，如數組或ArrayList什麼的，那上述方法仍然不安全，由於當外界對象經過get方法拿到這個instance對象

的引用後，又將其指向另外一個對象，那麼這個private變量也就變了，豈不是很危險。 這個時候就須要將get方法也加上synchronized同步，並

且，只返回這個private對象的clone()――這樣，調用端獲得的就是對象副本的引用了

 

出處：http://www.cnblogs.com/devinzhang/archive/2011/12/14/2287675.html