掌握這 8 個Synchronized 用法，你就厲害了！
? 幫助萬千Java學習者持續(xù)成長
作者｜Alben
albenw.github.io/posts/854fc091/
B 站搜索：楠哥教你學Java
獲取更多優(yōu)質視頻教程
簡介
本文將介紹8種同步方法的訪問場景，我們來看看這8種情況下，多線程訪問同步方法是否還是線程安全的。這些場景是多線程編程中經常遇到的，而且也是面試時高頻被問到的問題，所以不管是理論還是實踐，這些都是多線程場景必須要掌握的場景。
8個場景
接下來，我們來通過代碼實現(xiàn)，分別判斷以下場景是不是線程安全的，以及原因是什么。
兩個線程同時訪問同一個對象的同步方法
兩個線程同時訪問兩個對象的同步方法
兩個線程同時訪問（一個或兩個）對象的靜態(tài)同步方法
兩個線程分別同時訪問（一個或兩個）對象的同步方法和非同步方法
兩個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法
兩個線程同時訪問同一個對象的不同的同步方法
兩個線程分別同時訪問靜態(tài)synchronized和非靜態(tài)synchronized方法
同步方法拋出異常后，JVM會自動釋放鎖的情況
場景一：兩個線程同時訪問同一個對象的同步方法
分析：這種情況是經典的對象鎖中的方法鎖，兩個線程爭奪同一個對象鎖，所以會相互等待，是線程安全的。
「兩個線程同時訪問同一個對象的同步方法，是線程安全的。」
場景二：個線程同時訪問兩個對象的同步方法
這種場景就是對象鎖失效的場景，原因出在訪問的是兩個對象的同步方法，那么這兩個線程分別持有的兩個線程的鎖，所以是互相不會受限的。加鎖的目的是為了讓多個線程競爭同一把鎖，而這種情況多個線程之間不再競爭同一把鎖，而是分別持有一把鎖，所以我們的結論是：
「兩個線程同時訪問兩個對象的同步方法，是線程不安全的。」
代碼驗證：
public?class?Condition2?implements?Runnable?{??
????//?創(chuàng)建兩個不同的對象??
?static?Condition2?instance1?=?new?Condition2();??
?static?Condition2?instance2?=?new?Condition2();??
??
?@Override??
?public?void?run()?{??
??method();??
?}??
??
?private?synchronized?void?method()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，運行結束");??
?}??
??
?public?static?void?main(String[]?args)?{??
??Thread?thread1?=?new?Thread(instance1);??
??Thread?thread2?=?new?Thread(instance2);??
??thread1.start();??
??thread2.start();??
??while?(thread1.isAlive()?||?thread2.isAlive())?{??
??}??
??System.out.println("測試結束");??
?}??
}??
?
運行結果：
兩個線程是并行執(zhí)行的，所以線程不安全。
線程名：Thread-0，運行開始??
線程名：Thread-1，運行開始??
線程：Thread-0，運行結束??
線程：Thread-1，運行結束??
測試結束??
?
代碼分析：
「問題在此：」
兩個線程（thread1、thread2），訪問兩個對象（instance1、instance2）的同步方法（method()）,兩個線程都有各自的鎖，不能形成兩個線程競爭一把鎖的局勢，所以這時，synchronized修飾的方法method()和不用synchronized修飾的效果一樣（不信去把synchronized關鍵字去掉，運行結果一樣），所以此時的method()只是個普通方法。
「如何解決這個問題：」
若要使鎖生效，只需將method()方法用static修飾，這樣就形成了類鎖，多個實例（instance1、instance2）共同競爭一把類鎖，就可以使兩個線程串行執(zhí)行了。這也就是下一個場景要講的內容。
場景三：兩個線程同時訪問（一個或兩個）對象的靜態(tài)同步方法
這個場景解決的是場景二中出現(xiàn)的線程不安全問題，即用類鎖實現(xiàn)：
「兩個線程同時訪問（一個或兩個）對象的靜態(tài)同步方法，是線程安全的。」
場景四：兩個線程分別同時訪問（一個或兩個）對象的同步方法和非同步方法
這個場景是兩個線程其中一個訪問同步方法，另一個訪問非同步方法，此時程序會不會串行執(zhí)行呢，也就是說是不是線程安全的呢？
我們可以確定是線程不安全的，如果方法不加synchronized都是安全的，那就不需要同步方法了。驗證下我們的結論：
「兩個線程分別同時訪問（一個或兩個）對象的同步方法和非同步方法，是線程不安全的。」
public?class?Condition4?implements?Runnable?{??
??
?static?Condition4?instance?=?new?Condition4();??
??
?@Override??
?public?void?run()?{??
??//兩個線程訪問同步方法和非同步方法??
??if?(Thread.currentThread().getName().equals("Thread-0"))?{??
???//線程0,執(zhí)行同步方法method0()??
???method0();??
??}??
??if?(Thread.currentThread().getName().equals("Thread-1"))?{??
???//線程1,執(zhí)行非同步方法method1()??
???method1();??
??}??
?}??
??????
????//?同步方法??
?private?synchronized?void?method0()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，同步方法，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，同步方法，運行結束");??
?}??
??????
????//?普通方法??
?private?void?method1()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，普通方法，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，普通方法，運行結束");??
?}??
??
?public?static?void?main(String[]?args)?{??
??Thread?thread1?=?new?Thread(instance);??
??Thread?thread2?=?new?Thread(instance);??
??thread1.start();??
??thread2.start();??
??while?(thread1.isAlive()?||?thread2.isAlive())?{??
??}??
??System.out.println("測試結束");??
?}??
??
}??
?
運行結果：
兩個線程是并行執(zhí)行的，所以是線程不安全的。
線程名：Thread-0，同步方法，運行開始??
線程名：Thread-1，普通方法，運行開始??
線程：Thread-0，同步方法，運行結束??
線程：Thread-1，普通方法，運行結束??
測試結束??
?
結果分析
問題在于此：method1沒有被synchronized修飾，所以不會受到鎖的影響。即便是在同一個對象中，當然在多個實例中，更不會被鎖影響了。結論：
「非同步方法不受其它由synchronized修飾的同步方法影響」
你可能想到一個類似場景：多個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法，這個場景會是線程安全的嗎？
場景五：兩個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法
我們來實驗下這個場景，用兩個線程調用同步方法，在同步方法中調用普通方法；再用一個線程直接調用普通方法，看看是否是線程安全的？
public?class?Condition8?implements?Runnable?{??
??
?static?Condition8?instance?=?new?Condition8();??
??
?@Override??
?public?void?run()?{??
??if?(Thread.currentThread().getName().equals("Thread-0"))?{??
???//直接調用普通方法??
???method2();??
??}?else?{??
???//?先調用同步方法，在同步方法內調用普通方法??
???method1();??
??}??
?}??
??
?//?同步方法??
?private?static?synchronized?void?method1()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，同步方法，運行開始");??
??try?{??
???Thread.sleep(2000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，同步方法，運行結束,開始調用普通方法");??
??method2();??
?}??
??
?//?普通方法??
?private?static?void?method2()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，普通方法，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，普通方法，運行結束");??
?}??
??
?public?static?void?main(String[]?args)?{??
??//?此線程直接調用普通方法??
??Thread?thread0?=?new?Thread(instance);??
??//?這兩個線程直接調用同步方法??
??Thread?thread1?=?new?Thread(instance);??
??Thread?thread2?=?new?Thread(instance);??
??thread0.start();??
??thread1.start();??
??thread2.start();??
??while?(thread0.isAlive()?||?thread1.isAlive()?||?thread2.isAlive())?{??
??}??
??System.out.println("測試結束");??
?}??
??
}??
?
運行結果：
線程名：Thread-0，普通方法，運行開始??
線程名：Thread-1，同步方法，運行開始??
線程：Thread-1，同步方法，運行結束,開始調用普通方法??
線程名：Thread-1，普通方法，運行開始??
線程：Thread-0，普通方法，運行結束??
線程：Thread-1，普通方法，運行結束??
線程名：Thread-2，同步方法，運行開始??
線程：Thread-2，同步方法，運行結束,開始調用普通方法??
線程名：Thread-2，普通方法，運行開始??
線程：Thread-2，普通方法，運行結束??
測試結束??
?
結果分析：
我們可以看出，普通方法被兩個線程并行執(zhí)行，不是線程安全的。這是為什么呢？
因為如果非同步方法，有任何其他線程直接調用，而不是僅在調用同步方法時，才調用非同步方法，此時會出現(xiàn)多個線程并行執(zhí)行非同步方法的情況，線程就不安全了。
對于同步方法中調用非同步方法時，要想保證線程安全，就必須保證非同步方法的入口，僅出現(xiàn)在同步方法中。但這種控制方式不夠優(yōu)雅，若被不明情況的人直接調用非同步方法，就會導致原有的線程同步不再安全。所以不推薦大家在項目中這樣使用，但我們要理解這種情況，并且我們要用語義明確的、讓人一看就知道這是同步方法的方式，來處理線程安全的問題。
所以，最簡單的方式，是在非同步方法上，也加上synchronized關鍵字，使其變成一個同步方法，這樣就變成了《場景五：兩個線程同時訪問同一個對象的不同的同步方法》，這種場景下，大家就很清楚的看到，同一個對象中的兩個同步方法，不管哪個線程調用，都是線程安全的了。
所以結論是：
「兩個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法，僅在沒有其他線程直接調用非同步方法的情況下，是線程安全的。若有其他線程直接調用非同步方法，則是線程不安全的。」
場景六：兩個線程同時訪問同一個對象的不同的同步方法
這個場景也是在探討對象鎖的作用范圍，對象鎖的作用范圍是對象中的所有同步方法。所以，當訪問同一個對象中的多個同步方法時，結論是：
「兩個線程同時訪問同一個對象的不同的同步方法時，是線程安全的。」
public?class?Condition5?implements?Runnable?{??
?static?Condition5?instance?=?new?Condition5();??
??
?@Override??
?public?void?run()?{??
??if?(Thread.currentThread().getName().equals("Thread-0"))?{??
???//線程0,執(zhí)行同步方法method0()??
???method0();??
??}??
??if?(Thread.currentThread().getName().equals("Thread-1"))?{??
???//線程1,執(zhí)行同步方法method1()??
???method1();??
??}??
?}??
??
?private?synchronized?void?method0()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，同步方法0，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，同步方法0，運行結束");??
?}??
??
?private?synchronized?void?method1()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，同步方法1，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，同步方法1，運行結束");??
?}??
??
?//運行結果:串行??
?public?static?void?main(String[]?args)?{??
??Thread?thread1?=?new?Thread(instance);??
??Thread?thread2?=?new?Thread(instance);??
??thread1.start();??
??thread2.start();??
??while?(thread1.isAlive()?||?thread2.isAlive())?{??
??}??
??System.out.println("測試結束");??
?}??
}??
?
運行結果：
是線程安全的。
線程名：Thread-1，同步方法1，運行開始??
線程：Thread-1，同步方法1，運行結束??
線程名：Thread-0，同步方法0，運行開始??
線程：Thread-0，同步方法0，運行結束??
測試結束??
?
結果分析：
兩個方法（method0()和method1()）的synchronized修飾符，雖沒有指定鎖對象，但默認鎖對象為this對象為鎖對象，
所以對于同一個實例（instance），兩個線程拿到的鎖是同一把鎖，此時同步方法會串行執(zhí)行。這也是synchronized關鍵字的可重入性的一種體現(xiàn)。
場景七：兩個線程分別同時訪問靜態(tài)synchronized和非靜態(tài)synchronized方法
這種場景的本質也是在探討兩個線程獲取的是不是同一把鎖的問題。靜態(tài)synchronized方法屬于類鎖，鎖對象是（*.class）對象，非靜態(tài)synchronized方法屬于對象鎖中的方法鎖，鎖對象是this對象。兩個線程拿到的是不同的鎖，自然不會相互影響。結論：
「兩個線程分別同時訪問靜態(tài)synchronized和非靜態(tài)synchronized方法，線程不安全。」
代碼實現(xiàn)：
public?class?Condition6?implements?Runnable?{??
?static?Condition6?instance?=?new?Condition6();??
??
?@Override??
?public?void?run()?{??
??if?(Thread.currentThread().getName().equals("Thread-0"))?{??
???//線程0,執(zhí)行靜態(tài)同步方法method0()??
???method0();??
??}??
??if?(Thread.currentThread().getName().equals("Thread-1"))?{??
???//線程1,執(zhí)行非靜態(tài)同步方法method1()??
???method1();??
??}??
?}??
??
?//?重點：用static synchronized 修飾的方法，屬于類鎖，鎖對象為（*.class）對象。??
?private?static?synchronized?void?method0()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，靜態(tài)同步方法0，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，靜態(tài)同步方法0，運行結束");??
?}??
??
?//?重點：synchronized 修飾的方法，屬于方法鎖，鎖對象為（this）對象。??
?private?synchronized?void?method1()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，非靜態(tài)同步方法1，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，非靜態(tài)同步方法1，運行結束");??
?}??
??
?//運行結果:并行??
?public?static?void?main(String[]?args)?{??
??//問題原因：?線程1的鎖是類鎖（*.class）對象，線程2的鎖是方法鎖（this）對象,兩個線程的鎖不一樣，自然不會互相影響，所以會并行執(zhí)行。??
??Thread?thread1?=?new?Thread(instance);??
??Thread?thread2?=?new?Thread(instance);??
??thread1.start();??
??thread2.start();??
??while?(thread1.isAlive()?||?thread2.isAlive())?{??
??}??
??System.out.println("測試結束");??
?}??
?
運行結果：
線程名：Thread-0，靜態(tài)同步方法0，運行開始??
線程名：Thread-1，非靜態(tài)同步方法1，運行開始??
線程：Thread-1，非靜態(tài)同步方法1，運行結束??
線程：Thread-0，靜態(tài)同步方法0，運行結束??
測試結束??
?
場景八：同步方法拋出異常后，JVM會自動釋放鎖的情況
本場景探討的是synchronized釋放鎖的場景：
「只有當同步方法執(zhí)行完或執(zhí)行時拋出異常這兩種情況，才會釋放鎖。」
所以，在一個線程的同步方法中出現(xiàn)異常的時候，會釋放鎖，另一個線程得到鎖，繼續(xù)執(zhí)行。而不會出現(xiàn)一個線程拋出異常后，另一個線程一直等待獲取鎖的情況。這是因為JVM在同步方法拋出異常的時候，會自動釋放鎖對象。
代碼實現(xiàn)：
public?class?Condition7?implements?Runnable?{??
??
?private?static?Condition7?instance?=?new?Condition7();??
??
?@Override??
?public?void?run()?{??
??if?(Thread.currentThread().getName().equals("Thread-0"))?{??
???//線程0,執(zhí)行拋異常方法method0()??
???method0();??
??}??
??if?(Thread.currentThread().getName().equals("Thread-1"))?{??
???//線程1,執(zhí)行正常方法method1()??
???method1();??
??}??
?}??
??
?private?synchronized?void?method0()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??//同步方法中，當拋出異常時，JVM會自動釋放鎖，不需要手動釋放，其他線程即可獲取到該鎖??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，拋出異常，釋放鎖");??
??throw?new?RuntimeException();??
??
?}??
??
?private?synchronized?void?method1()?{??
??System.out.println("線程名："?+?Thread.currentThread().getName()?+?"，運行開始");??
??try?{??
???Thread.sleep(4000);??
??}?catch?(InterruptedException?e)?{??
???e.printStackTrace();??
??}??
??System.out.println("線程："?+?Thread.currentThread().getName()?+?"，運行結束");??
?}??
??
?public?static?void?main(String[]?args)?{??
??Thread?thread1?=?new?Thread(instance);??
??Thread?thread2?=?new?Thread(instance);??
??thread1.start();??
??thread2.start();??
??while?(thread1.isAlive()?||?thread2.isAlive())?{??
??}??
??System.out.println("測試結束");??
?}??
??
}??
?
運行結果：
線程名：Thread-0，運行開始??
線程名：Thread-0，拋出異常，釋放鎖??
線程名：Thread-1，運行開始??
Exception?in?thread?"Thread-0"?java.lang.RuntimeException??
?at?com.study.synchronize.conditions.Condition7.method0(Condition7.java:34)??
?at?com.study.synchronize.conditions.Condition7.run(Condition7.java:17)??
?at?java.lang.Thread.run(Thread.java:748)??
線程：Thread-1，運行結束??
測試結束??
?
結果分析：
可以看出線程還是串行執(zhí)行的，說明是線程安全的。而且出現(xiàn)異常后，不會造成死鎖現(xiàn)象，JVM會自動釋放出現(xiàn)異常線程的鎖對象，其他線程獲取鎖繼續(xù)執(zhí)行。
總結
本文總結了并用代碼實現(xiàn)和驗證了synchronized各種使用場景，以及各種場景發(fā)生的原因和結論。我們分析的理論基礎都是synchronized關鍵字的鎖對象究竟是誰？多個線程之間競爭的是否是同一把鎖？根據(jù)這個條件來判斷線程是否是安全的。所以，有了這些場景的分析鍛煉后，我們在以后使用多線程編程時，也可以通過分析鎖對象的方式，判斷出線程是否是安全的，從而避免此類問題的出現(xiàn)。
本文涵蓋了synchronized關鍵字的最重要的各種使用場景，也是面試官常常會問到的高頻問題，是一篇值得大家仔細閱讀和親自動手實踐的文章，喜歡本文請點贊和收藏。
楠哥簡介
資深 Java 工程師，微信號?southwindss
《Java零基礎實戰(zhàn)》一書作者
騰訊課程官方 Java 面試官，今日頭條認證大V
GitChat認證作者，B站認證UP主（楠哥教你學Java）
致力于幫助萬千 Java 學習者持續(xù)成長。
