Synchronized的底層實現原理是什么

Synchronized的底層實現原理是什么，很多新手對此不是很清楚，為了幫助大家解決這個難題，下面小編將為大家詳細講解，有這方面需求的人可以來學習下，希望你能有所收獲。

(1)給靜態方法加鎖

public class Main {         public static synchronized void staticSynPrint(String str) {         System.out.println(str);     }  }

靜態方法不屬于任何一個實例，而是屬于該類。不管該類被實例化多少次，靜態成員只有一份。在同一時刻，不管是使用實例.staticSynPrint方式還是直接類名.staticSynPrint的方式，都會進行同步處理。

(2)給靜態變量加鎖

同(1)，他們都是該類的靜態成員。

(3)synchronized(xxx.class)

public class Main {      public void classSynPrint(String str) {         synchronized (Main.class) {             System.out.println(str);         }     }  }

給當前類加鎖(注意是當前類，不是實例對象)，會作用于該類的所有實例對象，多個線程訪問Main類中的所有同步方法，都需要先進行同步處理。

(4)synchronized(this)

public class Main {      public void thisSynPrint(String str) {         synchronized (this) {             System.out.println(str);         }     }  }

this代表實例對象，因此現在鎖住的是當前實例對象，因此多個線程訪問不同實例的同步方法不需要進行同步。

(5)給實例方法加鎖

public class Main {      public synchronized void synPrint(String str) {         System.out.println(str);     }  }

不同線程訪問同一個實例底下的該方法，才會需要進行同步。

三、實際使用方式之一：單例模式中的雙重檢驗鎖

更多單例模式的種類可以參考我的另外一篇博文【設計模式】單例模式

public class SingletonDCL {     private volatile static SingletonDCL instance;      private SingletonDCL() {     }      public static SingletonDCL getInstance() {         if (instance == null) {             synchronized (Singleton.class) {                 if (instance == null) {                     instance = new SingletonDCL();                 }             }         }         return instance;     }  }

有幾個疑問：

(1)這里為什么要檢驗兩次null?

最初的想法，是直接利用synchronized將整個getInstance方法鎖起來，但這樣效率太低，考慮到實際代碼更為復雜，我們應當縮小鎖的范圍。

在單例模式下，要的就是一個單例，new SingletonDCL()只能被執行一次。因此，現在初步考慮成以下的這種方式：

public static SingletonDCL getInstance() {        if (instance == null) {            synchronized (Singleton.class) {                    //一些耗時的操作                    instance = new SingletonDCL();            }        }        return instance;    }

但這樣，存在一個問題。線程1判斷instance為null，然后拿到鎖，執行到了耗時的操作，阻塞了一會兒，還沒有對instance進行實例化，instance還是為null。線程2判斷instance為null，嘗試去獲取鎖。線程1實例化instance之后，釋放了鎖。而線程2獲取鎖之后，同樣進行了實例化操作。線程1和線程2拿到了兩個不同的對象，違背了單例的原則。

因此，在獲取鎖之后，又進行了一次null檢驗。

(2)為什么使用volatile 修飾單例變量?

關于volatie和synchronized的區別，可以先參考我的另外一篇文章【JAVA】volatile和synchronized的區別

這段代碼，instance = new SingletonDCL()，在虛擬機層面，其實分為了3個指令：

為instance分配內存空間，相當于堆中開辟出來一段空間

實例化instance，相當于在上一步開辟出來的空間上，放置實例化好的SingletonDCL對象

將instance變量引用指向第一步開辟出來的空間的首地址

但由于虛擬機做出的某些優化，可能會導致指令重排序，由1->2->3變成1->3->2。這種重新排序在單線程下不會有任何問題，但出于多線程的情況下，可能會出現以下的問題：

線程1獲取鎖之后，執行到了instance = new  SingletonDCL()階段，此時，剛好由于虛擬機進行了指令重排序，先進行了第1步開辟內存空間，然后執行了第3步，instance指向空間首地址，第2步還沒來得及執行，此時恰好有線程2執行getInstance方法，最外層判斷instance不為null(instance已經指向了某一段地址，因此不為null)，直接返回了單例對象，接著線程2在獲取單例對象屬性的時候，出現了空指針錯誤!

因此使用volatile 修飾單例變量，可以避免由于虛擬機的指令重排序機制可能導致的空指針異常。

四、實現原理

這里可以分兩種情況討論：

(1)同步語句塊

public class Main {      public static final Object object = new Object();      public void print() {         synchronized (object) {             System.out.println("123");         }     }  }

使用java Main.java，之后使用javap -c Main.class(-c代表反匯編)得到：

public class com.yang.testSyn.Main {   public static final java.lang.Object object;    public com.yang.testSyn.Main();     Code:        0: aload_0        1: invokespecial #1                  // Method java/lang/Object."<init>":()V        4: return    public void print();     Code:        0: getstatic     #2                  // Field object:Ljava/lang/Object;        3: dup        4: astore_1        5: monitorenter        6: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;        9: ldc           #4                  // String 123       11: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V       14: aload_1       15: monitorexit       16: goto          24       19: astore_2       20: aload_1       21: monitorexit       22: aload_2       23: athrow       24: return     Exception table:        from    to  target type            6    16    19   any           19    22    19   any    static {};     Code:        0: new           #6                  // class java/lang/Object        3: dup        4: invokespecial #1                  // Method java/lang/Object."<init>":()V        7: putstatic     #2                  // Field object:Ljava/lang/Object;       10: return }

其中print方法中的第5行、15行出現了monitorenter和monitorexit，而這兩行其中的字節碼代表的正是同步語句塊里的內容。

當線程執行到monitorenter時，代表即將進入到同步語句塊中，線程首先需要去獲得Object的對象鎖，而對象鎖處于每個java對象的對象頭中，對象頭中會有一個鎖的計數器，當線程查詢對象頭中計數器，發現內容為0時，則代表該對象沒有被任何線程所占有，此時該線程可以占有此對象，計數器于是加1。

線程占有該對象后，也就是拿到該對象的鎖，可以執行同步語句塊里面的方法。此時，如果有其他線程進來，查詢對象頭發現計數器不為0，于是進入該對象的鎖等待隊列中，一直阻塞到計數器為0時，方可繼續執行。

第一個線程執行到enterexit后，釋放了Object的對象鎖，此時第二個線程可以繼續執行。

這邊依然有幾個問題：

[1]為什么有一個monitorenter指令，卻有兩個monitorexit指令?

因為編譯器必須保證，無論同步代碼塊中的代碼以何種方式結束(正常 return 或者異常退出)，代碼中每次調用 monitorenter 必須執行對應的  monitorexit 指令。為了保證這一點，編譯器會自動生成一個異常處理器，這個異常處理器的目的就是為了同步代碼塊拋出異常時能執行  monitorexit。這也是字節碼中，只有一個 monitorenter 卻有兩個 monitorexit 的原因。

當然這一點，也可以從Exception  table(異常表)中看出來，字節碼中第6(from)到16(to)的偏移量中如果出現任何類型(type)的異常，都會跳轉到第19(target)行。

(2)同步方法

public class Main {      public synchronized void print(String str) {         System.out.println(str);     }  }

使用javap -v Main.class查看

-v 選項可以顯示更加詳細的內容，比如版本號、類訪問權限、常量池相關的信息，是一個非常有用的參數。

public class com.yang.testSyn.Main   minor version: 0   major version: 52   flags: ACC_PUBLIC, ACC_SUPER Constant pool:    #1 = Methodref          #5.#14         // java/lang/Object."<init>":()V    #2 = Fieldref           #15.#16        // java/lang/System.out:Ljava/io/PrintStream;    #3 = Methodref          #17.#18        // java/io/PrintStream.println:(Ljava/lang/String;)V    #4 = Class              #19            // com/yang/testSyn/Main    #5 = Class              #20            // java/lang/Object    #6 = Utf8               <init>    #7 = Utf8               ()V    #8 = Utf8               Code    #9 = Utf8               LineNumberTable   #10 = Utf8               print   #11 = Utf8               (Ljava/lang/String;)V   #12 = Utf8               SourceFile   #13 = Utf8               Main.java   #14 = NameAndType        #6:#7          // "<init>":()V   #15 = Class              #21            // java/lang/System   #16 = NameAndType        #22:#23        // out:Ljava/io/PrintStream;   #17 = Class              #24            // java/io/PrintStream   #18 = NameAndType        #25:#11        // println:(Ljava/lang/String;)V   #19 = Utf8               com/yang/testSyn/Main   #20 = Utf8               java/lang/Object   #21 = Utf8               java/lang/System   #22 = Utf8               out   #23 = Utf8               Ljava/io/PrintStream;   #24 = Utf8               java/io/PrintStream   #25 = Utf8               println {   public com.yang.testSyn.Main();     descriptor: ()V     flags: ACC_PUBLIC     Code:       stack=1, locals=1, args_size=1          0: aload_0          1: invokespecial #1                  // Method java/lang/Object."<init>":()V          4: return       LineNumberTable:         line 3: 0    public synchronized void print(java.lang.String);     descriptor: (Ljava/lang/String;)V     flags: ACC_PUBLIC, ACC_SYNCHRONIZED     Code:       stack=2, locals=2, args_size=2          0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;          3: aload_1          4: invokevirtual #3                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V          7: return       LineNumberTable:         line 32: 0         line 33: 7 }

只看最后兩個方法，第一個方法是編譯后自動生成的默認構造方法，第二個方法則是我們的同步方法，可以看到同步方法比默認的構造方法多了一個ACC_SYNCHRONIZED的標志位。

與同步語句塊不同，虛擬機不會在字節碼層面實現鎖同步，而是會先觀察該方法是否含有ACC_SYNCHRONIZED標志。如果含有，則線程會首先嘗試獲取鎖。如果是實例方法，則會嘗試獲取實例鎖;如果是靜態方法(類方法)，則會嘗試獲取類鎖。最后不管方法執行是否出現異常，都會釋放鎖。

看完上述內容是否對您有幫助呢？如果還想對相關知識有進一步的了解或閱讀更多相關文章，請關注億速云行業資訊頻道，感謝您對億速云的支持。