java synchronized詳解

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

     一、當兩個並發執行緒存取同一個物件object中的這個synchronized(this)同步程式碼區塊時，一個時間內只能有一個執行緒來執行。另一個執行緒必須等待目前執行緒執行完這個程式碼區塊以後才能執行該程式碼區塊。

     二、然而，當一個執行緒存取object的一個synchronized(this)同步程式碼區塊時，另一個執行緒仍可存取該object中的非synchronized(this)同步程式碼區塊。

     三、尤其關鍵的是，當一個執行緒存取object的一個synchronized(this)同步程式碼區塊時，其他執行緒對object中所有其它synchronized(this)同步程式碼區塊的存取將被阻塞。

     四、第三個例子同樣適用其它同步程式碼區塊。也就是說，當一個執行緒存取object的一個synchronized(this)同步程式碼區塊時，它就獲得了這個object的物件鎖定。結果，其它執行緒對該object物件所有同步程式碼部分的存取都被暫時阻塞。

     五以上規則對其它物件鎖定同樣適用.

舉例說明：  
     一、當兩個並發執行緒存取同一個物件object中的這個synchronized(this)只能同步區塊有一個時間段有一個空間內的這個synchronized(this)線程得到執行。另一個執行緒必須等待目前執行緒執行完這個程式碼區塊以後才能執行該程式碼區塊。

package ths;

public class Thread1 implements Runnable {  
     public void run() {  
           for (int i = 0; i                     System.out.println(Thread. currentThread().getName() + " synchronized loop " + i);  
               }  
   public static void main(String[] args) {  
          Thread1 t1 = new Thread1();  
      t1, "A");  
          Thread tb = new Thread(t1, "B");  
        
     } 
}

結果：  
     A synchronized loop 0  
     A synchronized loop 1  

     A synchronized loop 2  

     A synchronized loop 3    
     B synchronized loop 1  
     B synchronized loop 2  
       二、然而，當當一個執行緒存取object的一個synchronized(this)同步程式碼區塊時，另一個執行緒仍然可以存取該object中的非synchronized(this)同步程式碼區塊。

package ths;

public class Thread2 {  
     public void m4t1() {  
          synchroniz  
               while( i-- > 0) {  
              
                    嘗試 {  
            }
                    } catch (InterruptedException 即) {  
             }  
          }  
     }  
     
          while( i-- > 0) {  
              。  
               嘗試 {  
                 }
               } catch (InterruptedException ie) {  
             }  
     public static void main(String[] args) {  
          以最終步驟 2 步驟myt2 = 新執行緒2();  
          執行緒 t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  );  
          執行緒 t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );  
          t1.start();  
          t2.start();  
     } 
}

結果：  
     t1 : 4  
     t2 : 
     t1 : 2  

    t 2：2  

     t1：1  
    
三、尤其關鍵的是，當一個執行緒存取物件的一個synchronized(this)同步程式碼區塊時，其他執行緒對物件中所有其他synchronized(this)同步程式碼區塊的存取將被阻塞。

     //修改Thread2.m4t2()方法：  
     public void m4t2() {  
          syn 
          int i = 5;  
               while( i-- > 0) {  
    ().getName() + " : " + i);  
                       .sleep(500);  
                    } catch (InterruptedException ie) {                 }  
          }

    4  
     t1 : 3  

     t1 : 2  

     t1 :     t2 : 3  

     t2 : 2  

     t2 : 1  

     t2 : 0

🎠
     t2 : 0
🎠塊。也就是說，當一個執行緒存取object的一個synchronized(this)同步程式碼區塊時，它就獲得了這個object的物件鎖定。結果，其它執行緒對該object物件所有同步程式碼部分的存取都被暫時阻塞。

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

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

              

結果：  

     t1 : 4  

     t1 : 3  

t1 : 2  

     t1 : 1  
     t1 : 0  
     t2 : 4       
     t2 : 1  
     t2 : 0

     五以上規則對其它物件鎖定同樣適用:

ths;

public class Thread3 { 
     class Inner { 
          private void m4t1() {     
               while(i-- > 0) { 
              i); 
                    嘗試 { 
            }
                    } catch(InterruptedException ie) { 
             } 
          } 
          private void m4   
               while(i-- > 0) { 
              i); 
                    嘗試 { 
            
                    } catch(InterruptedException ie) { 
            } 
          } 
     } 
     
          inner.m4t1(); 
     } 
     private void m4t2(Inner 內) { 
          inner.m4t2(); 
     } 
     public static void main(String[] args) { 
          Final Thread3 myt3 = new Thread3(); 
          最終內部 內部 = myt3.new Inner(); 
          執行緒 t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1"); 
     執行緒 t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, "t2"); 
     t1.start(); 
     t2.start(); 
  } 
}

結果：

雖然threadt1獲得了對Inner的物件鎖定，但是由於threadt2存取的是同一個Inner中的非同步部分。 ()=4  
     t2 : 內部.m4t2()=4  

     t1 : 內部.m4t1()=3   1()=2  

   t2：內部.m 4t2 ()=2  

     t1 : Inner.m4t1()=1  

     t2 : Inner.m4t2()=1   .m4t2()=0

現在在Inner 。

     private synchronized void m4t2() {  
          int i = 5;              System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);  
               try {  
            }        } catch(InterruptedException ie) {  
               }  
儘管線程t1與t2訪問了同一個Inner物件中兩個毫不相關的部分,但因為t1先獲得了對Inner的對象鎖，所以t2對Inner.m4t2()的訪問也被阻塞，因為m4t2()是Inner中的一個同步方法。

     t1 : Inner.m4t1()=4  
     t1 : Inner.m4t1()=3  
   ner t1 : In . =1  

     t1 : Inner.m4t1()= 0  

     t2 : Inner.m4t2()=4  

     t2 : Inner.m4t2()=3  

     t2 : Inner.m4m  )=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用法

，大門永遠打開。房子裡有 很多房間（也就是方法）。

這些房間有上鎖的（synchronized方法）， 和不上鎖之分（普通方法）。房門口放著一把鑰匙（key），這把鑰匙可以打開所有上鎖的房間。

另外我把所有想調用該物件方法的線程比喻成想進入這房子某個 房間的人。所有的東西就這麼多了，下面我們來看看這些東西之間如何運作的。

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

一個人想進入某間上了鎖的房間，他來到房子門口，看見鑰匙在那兒（說明暫時還沒有其他人要使用上鎖的 房間）。於是他走上去拿到了鑰匙

，並且按照自己 的計劃使用那些房間。注意一點，他每次使用完一次上鎖的房間後會馬上把鑰匙還回去。即使他要連續使用兩間上鎖的房間，

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

因此，普通情況下鑰匙的使用原則是：「隨用隨借，用完即還。」

這時其他人可以不受限制的使用那些不上鎖的房間，一個人用一間可以，兩個人用一間也可以，沒限制。但是如果當某個人想要進入上鎖的房

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

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

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

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

到，等等。出判斷，而是

根據很多條。

。知道，計算機裡隨機數的學名是偽隨機數，是人運用一定的方法寫出來的，看上去隨機罷了。確定就不確定了吧。和同步方法有小小的不同。

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 TxxThread(). read( tt).start(); 
   new Thread(tt).start(); 
   new Thread(tt).start(); 
} 
}

class TxtThread implements Runnabled new String();

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

 } catch (Exception e) { 
      e. getMessage(); 
     } 

     System.out.println(Thread.currentThread().getName() 

     
}

上面的例子中為了製造一個時間差,也就是出錯的機會,使用了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)處的this指的是什麼呢？它指的就是呼叫這個方法的對象，如P1。可見同步方法實質是將synchronized作用於object reference。 ――那個

拿到了P1物件鎖的線程，才可以呼叫P1的同步方法，而對P2而言，P1這個鎖與它毫不相干，程式也可能在這種情形下擺脫同步機制的控制，造

成資料混亂：（

2．同步區塊，範例程式碼如下：

public void method3(SomeObject so)

{

   

    }

}

這時，鎖就是so這個對象，誰拿到這個鎖誰就可以運行它所控制的那段代碼。

確的物件作為鎖，只是想讓一段程式碼同步時，可以創造一個特殊的instance變數（它得是一個物件）來充當鎖定：

class Foo implements Runnable

{

     new byte[0]; // 特殊的instance變數

        Public void methodA() 

        {

      }

        //…..

}

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

= new Object()則需要7行操作碼。       //…. 

    }

    public void methodBBB() 

    {

       synchronized(Foo.class)  程式碼中的methodBBB()方法是把class literal當鎖的情況，它和同步的static函數所產生的效果是一樣的，所取得的鎖很特別，是目前呼叫這

個方法的物件所屬的類別（Class，而不再是由這個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()――這樣，呼叫端得到的就是物件副本的引用了