(Java 多線程系列)java synchronized詳解

時間 2019-11-11

標籤 java 多線程系列 synchronized 詳解欄目 Java 简体版

原文原文鏈接

synchronized簡介java

　　Java提供了一種內置的鎖機制來支持原子性：同步代碼塊(Synchronized Block)。同步代碼塊包括兩部分：一個做爲鎖對象的引用，一個做爲由這個鎖保護的代碼塊。以關鍵字synchronized來修飾的方法就是一種橫跨整個方法體的同步代碼塊，其中該同步代碼塊的鎖就是方法調用全部的對象。靜態的synchronized方法以class對象做爲鎖。數組

synchronized(this){
       //訪問或修改由鎖保護的共享狀態
}

　　每一個Java對象均可以用作一個實現同步的鎖，這些鎖稱爲內置鎖或監視鎖，Java的內置鎖至關於一種互斥鎖，這意味着最多隻有一個線程能持有這種鎖。其訪問規則爲：多線程

當兩個併發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程獲得執行。另外一個線程必須等待當前線程執行完這個代碼塊之後才能執行該代碼塊。
然而，當一個線程訪問object的一個synchronized(this)同步代碼塊時，另外一個線程仍然能夠訪問該object中的非synchronized(this)同步代碼塊。
尤爲關鍵的是，當一個線程訪問object的一個synchronized(this)同步代碼塊時，其餘線程對object中全部其它synchronized(this)同步代碼塊的訪問將被阻塞。
第三個例子一樣適用其它同步代碼塊。也就是說，當一個線程訪問object的一個synchronized(this)同步代碼塊時，它就得到了這個object的對象鎖。結果，其它線程對該object對象全部同步代碼部分的訪問都被暫時阻塞。
以上規則對其它對象鎖一樣適用.

實例說明併發

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

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

程序執行結果爲：oop

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

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

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

    public static void main(String[] args) {  
         final Test myt2 = new Test();  
         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();  
    } 
}

程序執行結果爲：spa

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

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

    public static void main(String[] args) {  
         final Test myt2 = new Test();  
         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();  
    } 
}

程序執行結果爲：code

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

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

    public static void main(String[] args) {  
         final Test myt2 = new Test();  
         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();  
    } 
}

程序執行結果爲：

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

public class Test { 
    class Inner { 
         private void m4t1() { 
              int i = 3; 
              while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i); 
                   try { 
                        Thread.sleep(500); 
                   } catch(InterruptedException ie) { 
                   } 
              } 
         } 

         private void m4t2() { 
              int i = 3; 
              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 Test myt3 = new Test(); 
         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中的非同步部分。因此兩個線程互不干擾。

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

private synchronized void m4t2() {  
  int i = 3;  
  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中的一個同步方法。

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關鍵字能夠做爲函數的修飾符，也可做爲函數內的語句，也就是平時說的同步方法和同步語句塊。若是再細的分類，synchronized可做用於instance變量、object reference（對象引用）、static函數和class literals(類名稱字面常量)身上。

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

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

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

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

　　D. 通常的同步方法與synchronized (this)效果同樣，都是鎖定調用這個同步方法對象（該類的一個具體實例）

　　 E. 靜態同步方法與synchronized (Class.this)效果同樣，鎖定的是當前調用這個方法的對象所屬的類（Class，而再也不是由這個Class產生的某個具體對象了）。

　　F. 若是同時定義通常的同步方法和靜態同步方法，那麼這個類的同一對象Obj。在多線程中分別訪問A和B兩個方法時，不會構成同步，由於它們的鎖都不同。A方法的鎖是Obj這個對象

　　接着來討論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 methodA(){   // 同步的static 函數 //…. 
    }
    public void methodB() {
       synchronized(Foo.class)   // class literal(類名稱字面常量)
    } 
}

　　代碼中的methodB()方法是把class literal做爲鎖的狀況，它和同步的static函數產生的效果是同樣的，取得的鎖很特別，是當前調用這個方法的對象所屬的類（Class，而再也不是由這個Class產生的某個具體對象了）。

　　若是一個類中定義了一個synchronized的static函數A，也定義了一個synchronized 的instance函數B，那麼這個類的同一對象Obj。在多線程中分別訪問A和B兩個方法時，不會構成同步，由於它們的鎖都不同。A方法的鎖是Obj這個對象，而B的鎖是Obj所屬的那個Class。(經驗證在多線程中分別訪問A和B兩個方法時，不會構成同步)

public class SynTest{
    public static void main(String[] args) { 
         final SynTest mSynTest = new SynTest(); 
         Thread t1 = new Thread(new Runnable() {
            public void run() { 
                mSynTest.methodA();
            } 
         }, "t1"); 
         Thread t2 = new Thread( new Runnable() {
            public void run() { 
                mSynTest.methodB();
            } 
         }, "t2"); 
         t1.start(); 
         t2.start(); 
    } 
    public synchronized void methodA() {  
        int i = 3;  
        while( i-- > 0) {  
             System.out.println(Thread.currentThread().getName() + " : " + i);  
             try {  
                  Thread.sleep(5);  
             } catch (InterruptedException ie) {  
             }  
        }  
    }
    public synchronized static void methodB() {  
        int i = 3;  
        while( i-- > 0) {  
             System.out.println(Thread.currentThread().getName() + " : " + i);  
             try {  
                  Thread.sleep(5);  
             } catch (InterruptedException ie) {  
             }  
        }  
   }
}