synchronized關鍵字的詳細使用

首先聲明，轉自：

http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html

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

一、當兩個并發線程通路同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間内隻能有一個線程得到執行。另一個線程必須等待目前線程執行完這個代碼塊以後才能執行該代碼塊。

 二、然而，當一個線程通路object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以通路該object中的非synchronized(this)同步代碼塊。

 三、尤其關鍵的是，當一個線程通路object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)同步代碼塊的通路将被阻塞。

 四、第三個例子同樣适用其它同步代碼塊。也就是說，當一個線程通路object的一個synchronized(this)同步代碼塊時，它就獲得了這個object的對象鎖。結果，其它線程對該object對象所有同步代碼部分的通路都被暫時阻塞。

 五、以上規則對其它對象鎖同樣适用.

舉例說明：

一、當兩個并發線程通路同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間内隻能有一個線程得到執行。另一個線程必須等待目前線程執行完這個代碼塊以後才能執行該代碼塊。

package ths;

public class Thread1 implements Runnable {

public void run() {

synchronized(this) {

for (int i = 0; i < 5; i++) {

System.out.println(Thread.currentThread().getName() + ” synchronized loop ” + i);

}

public static void main(String[] args) {

Thread1 t1 = new Thread1();

Thread ta = new Thread(t1, “A”);

Thread tb = new Thread(t1, “B”);

ta.start();

tb.start();

}

結果：

A synchronized loop 0

A synchronized loop 1

A synchronized loop 2

A synchronized loop 3

A synchronized loop 4

B synchronized loop 0

B synchronized loop 1

B synchronized loop 2

B synchronized loop 3

B synchronized loop 4

二、然而，當一個線程通路object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以通路該object中的非synchronized(this)同步代碼塊。

package ths;

public class Thread2 {

public void m4t1() {

synchronized(this) {

int i = 5;

while( i– > 0) {

System.out.println(Thread.currentThread().getName() + ” : ” + i);

try {

Thread.sleep(500);

} catch (InterruptedException ie) {

}

public void m4t2() {

int i = 5;

while( i– > 0) {

System.out.println(Thread.currentThread().getName() + ” : ” + i);

try {

Thread.sleep(500);

} catch (InterruptedException ie) {

}

public static void main(String[] args) {

final Thread2 myt2 = new Thread2();

Thread t1 = new Thread( new Runnable() { public void run() { myt2.m4t1(); } }, “t1” );

Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t2(); } }, “t2” );

t1.start();

t2.start();

}

結果：

t1 : 4

t2 : 4

t1 : 3

t2 : 3

t1 : 2

t2 : 2

t1 : 1

t2 : 1

t1 : 0

t2 : 0

三、尤其關鍵的是，當一個線程通路object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)同步代碼塊的通路将被阻塞。

 //修改Thread2.m4t2()方法：  
 public void m4t2() {  
      synchronized(this) {  
           int i = 5;  
           while( i-- > 0) {  
                System.out.println(Thread.currentThread().getName() + " : " + i);  
                try {  
                     Thread.sleep(500);  
                } catch (InterruptedException ie) {  
                }  
           }  
      }

 }

結果：

t1 : 4  
 t1 : 3  
 t1 : 2  
 t1 : 1  
 t1 : 0  
 t2 : 4  
 t2 : 3  
 t2 : 2  
 t2 : 1  
 t2 : 0

 四、第三個例子同樣适用其它同步代碼塊。也就是說，當一個線程通路object的一個synchronized(this)同步代碼塊時，它就獲得了這個object的對象鎖。結果，其它線程對該object對象所有同步代碼部分的通路都被暫時阻塞。

 //修改Thread2.m4t2()方法如下：

 public synchronized void m4t2() {  
      int i = 5;  
      while( i-- > 0) {  
           System.out.println(Thread.currentThread().getName() + " : " + i);  
           try {  
                Thread.sleep(500);  
           } catch (InterruptedException ie) {  
           }  
      }  
 }

結果：

t1 : 4

t1 : 3

t1 : 2

t1 : 1

t1 : 0

t2 : 4

t2 : 3

t2 : 2

t2 : 1

t2 : 0

五、以上規則對其它對象鎖同樣适用:

package ths;

public class Thread3 {

class Inner {

private void m4t1() {

int i = 5;

while(i– > 0) {

System.out.println(Thread.currentThread().getName() + ” : Inner.m4t1()=” + i);

try {

Thread.sleep(500);

} catch(InterruptedException ie) {

}

private void m4t2() {

int i = 5;

while(i– > 0) {

System.out.println(Thread.currentThread().getName() + ” : Inner.m4t2()=” + i);

try {

Thread.sleep(500);

} catch(InterruptedException ie) {

}

private void m4t1(Inner inner) {

synchronized(inner) { //使用對象鎖

inner.m4t1();

}

private void m4t2(Inner inner) {

inner.m4t2();

}

public static void main(String[] args) {

final Thread3 myt3 = new Thread3();

final Inner inner = myt3.new Inner();

Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, “t1”);

Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, “t2”);

t1.start();

t2.start();

}

結果：

盡管線程t1獲得了對Inner的對象鎖，但由于線程t2通路的是同一個Inner中的非同步部分。是以兩個線程互不幹擾。

t1 : Inner.m4t1()=4  
 t2 : Inner.m4t2()=4  
 t1 : Inner.m4t1()=3  
 t2 : Inner.m4t2()=3  
 t1 : Inner.m4t1()=2  
 t2 : Inner.m4t2()=2  
 t1 : Inner.m4t1()=1  
 t2 : Inner.m4t2()=1  
 t1 : Inner.m4t1()=0  
 t2 : Inner.m4t2()=0

現在在Inner.m4t2()前面加上synchronized：

private synchronized void m4t2() {  
      int i = 5;  
      while(i-- > 0) {  
           System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);  
           try {  
                Thread.sleep(500);  
           } catch(InterruptedException ie) {  
           }  
      }  
 }

結果：

盡管線程t1與t2通路了同一個Inner對象中兩個毫不相關的部分,但因為t1先獲得了對Inner的對象鎖，是以t2對Inner.m4t2()的通路也被阻塞，因為m4t2()是Inner中的一個同步方法。

t1 : Inner.m4t1()=4  
 t1 : Inner.m4t1()=3  
 t1 : Inner.m4t1()=2  
 t1 : Inner.m4t1()=1  
 t1 : Inner.m4t1()=0  
 t2 : Inner.m4t2()=4  
 t2 : Inner.m4t2()=3  
 t2 : Inner.m4t2()=2  
 t2 : Inner.m4t2()=1  
 t2 : Inner.m4t2()=0

第二篇：

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)的一些了解

一、當兩個并發線程通路同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間内隻能有一個線程得到執行。另一個線

程必須等待目前線程執行完這個代碼塊以後才能執行該代碼塊。

二、然而，當一個線程通路object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以通路該object中的非synchronized

(this)同步代碼塊。

三、尤其關鍵的是，當一個線程通路object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)

同步代碼塊的通路将被阻塞。

四、第三個例子同樣适用其它同步代碼塊。也就是說，當一個線程通路object的一個synchronized(this)同步代碼塊時，它就獲得了這個

object的對象鎖。結果，其它線程對該object對象所有同步代碼部分的通路都被暫時阻塞。

五、以上規則對其它對象鎖同樣适用

http://hi.baidu.com/sunshibing/blog/item/5235b9b731d48ff430add14a.html

java中synchronized用法

打個比方：一個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();

}

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用到不同地方對代碼産生的影響：

假設P1、P2是同一個類的不同對象，這個類中定義了以下幾種情況的同步塊或同步方法，P1、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()――這樣，調用端得到的就是對象副本的引用了

synchronized關鍵字的詳細使用

繼續閱讀

同步、異步

Python 單線程與多線程批量下載下傳的比較

ROS學習（十四）：ROS Spinning

讀書筆記-現代作業系統-2程序與線程-2.4排程

WebWorker進階

01.JAVA并發程式設計-線程的使用-基本概念線程定義線程狀态線程優先級線程優勢線程問題守護線程（Daemon Thread）參考資料

C#建立線程三種方式

Android中更新UI的三種方式

四大元件之——server（服務）及Aidl（接口定義語言）

iOS - 解決This application is modifying the autolayout engine from a background thread

This application is modifying the autolayout engine from a background thread 原因

This application is modifying the autolayout engine from a background thread, which can lead

go中channel和goroutine以及select的配合使用

線程通信和程序通信差別（線程程序差別）

程序與線程及通信總結

ThreadLocal 線程局部變量ThreadLocal線程局部變量