java 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、以上規則對其它對象鎖一樣適用.

舉例說明：  
     1、當兩個併發線程訪問同一個對象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

     2、然而，當一個線程訪問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

     3、尤爲關鍵的是，當一個線程訪問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

     4、第三個例子一樣適用其它同步代碼塊。也就是說，當一個線程訪問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

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

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)的一些理解 
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、以上規則對其它對象鎖一樣適用

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(); 
   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()――這樣，調用端獲得的就是對象副本的引用了