Java多線程訪問Synchronized同步方法的八種使用場景

簡介

本文將介紹7種同步方法的訪問場景，咱們來看看這七種狀況下，多線程訪問同步方法是否仍是線程安全的。這些場景是多線程編程中常常遇到的，並且也是面試時高頻被問到的問題，因此不論是理論仍是實踐，這些都是多線程場景必需要掌握的場景。java

八種使用場景：

接下來，咱們來經過代碼實現，分別判斷如下場景是否是線程安全的，以及緣由是什麼。程序員

兩個線程同時訪問同一個對象的同步方法面試
兩個線程同時訪問兩個對象的同步方法編程
兩個線程同時訪問（一個或兩個）對象的靜態同步方法設計模式
兩個線程分別同時訪問（一個或兩個）對象的同步方法和非同步方法安全
兩個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法網絡
兩個線程同時訪問同一個對象的不一樣的同步方法多線程
兩個線程分別同時訪問靜態synchronized和非靜態synchronized方法ide
同步方法拋出異常後，JVM會自動釋放鎖的狀況測試

場景一：兩個線程同時訪問同一個對象的同步方法

分析：這種狀況是經典的對象鎖中的方法鎖，兩個線程爭奪同一個對象鎖，因此會相互等待，是線程安全的。

兩個線程同時訪問同一個對象的同步方法，是線程安全的。
1

咱們在前文中已經講過了。代碼和詳細講解在《Java中synchronized實現對象鎖的兩種方式及原理解析》中的第二部分《方法鎖》中，在此就再也不重述了。

場景二：兩個線程同時訪問兩個對象的同步方法

這種場景就是對象鎖失效的場景，緣由出在訪問的是兩個對象的同步方法，那麼這兩個線程分別持有的兩個線程的鎖，因此是互相不會受限的。加鎖的目的是爲了讓多個線程競爭同一把鎖，而這種狀況多個線程之間再也不競爭同一把鎖，而是分別持有一把鎖，因此咱們的結論是：

兩個線程同時訪問兩個對象的同步方法，是線程不安全的。
1

代碼驗證：

public class Condition2 implements Runnable {
    // 建立兩個不一樣的對象
 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("測試結束");
 }
}
123456789101112131415161718192021222324252627282930

運行結果：

兩個線程是並行執行的，因此線程不安全。

關注公衆號：程序員白楠楠，領取2020年底總結面試題

線程名：Thread-0，運行開始
線程名：Thread-1，運行開始
線程：Thread-0，運行結束
線程：Thread-1，運行結束
測試結束
12345

代碼分析：

「問題在此：」兩個線程（thread一、thread2），訪問兩個對象（instance一、instance2）的同步方法（method()）,兩個線程都有各自的鎖，不能造成兩個線程競爭一把鎖的局勢，因此這時，synchronized修飾的方法method()和不用synchronized修飾的效果同樣（不信去把synchronized關鍵字去掉，運行結果同樣），因此此時的method()只是個普通方法。

「如何解決這個問題：」若要使鎖生效，只需將method()方法用static修飾，這樣就造成了類鎖，多個實例（instance一、instance2）共同競爭一把類鎖，就可使兩個線程串行執行了。這也就是下一個場景要講的內容。

場景三：兩個線程同時訪問（一個或兩個）對象的靜態同步方法

這個場景解決的是場景二中出現的線程不安全問題，即用類鎖實現：

兩個線程同時訪問（一個或兩個）對象的靜態同步方法，是線程安全的。
1

關於此方法的代碼實現和詳細講解，參考文章《Java中synchronized實現類鎖的兩種方式及原理解析》中的第二部分《靜態方法鎖的方式實現類鎖》，在此再也不重述。

場景四：兩個線程分別同時訪問（一個或兩個）對象的同步方法和非同步方法

這個場景是兩個線程其中一個訪問同步方法，另外一個訪問非同步方法，此時程序會不會串行執行呢，也就是說是否是線程安全的呢？咱們能夠肯定是線程不安全的，若是方法不加synchronized都是安全的，那就不須要同步方法了。驗證下咱們的結論：

兩個線程分別同時訪問（一個或兩個）對象的同步方法和非同步方法，是線程不安全的。
1
public class Condition4 implements Runnable {

 static Condition4 instance = new Condition4();

 @Override
 public void run() {
  //兩個線程訪問同步方法和非同步方法
  if (Thread.currentThread().getName().equals("Thread-0")) {
   //線程0,執行同步方法method0()
   method0();
  }
  if (Thread.currentThread().getName().equals("Thread-1")) {
   //線程1,執行非同步方法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("測試結束");
 }

}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

運行結果：

兩個線程是並行執行的，因此是線程不安全的。

線程名：Thread-0，同步方法，運行開始
線程名：Thread-1，普通方法，運行開始
線程：Thread-0，同步方法，運行結束
線程：Thread-1，普通方法，運行結束
測試結束
12345

結果分析

「問題在於此：」 method1沒有被synchronized修飾，因此不會受到鎖的影響。即使是在同一個對象中，固然在多個實例中，更不會被鎖影響了。結論：

非同步方法不受其它由synchronized修飾的同步方法影響
1

你可能想到一個相似場景：多個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法，這個場景會是線程安全的嗎？

場景五：兩個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法

咱們來實驗下這個場景，用兩個線程調用同步方法，在同步方法中調用普通方法；再用一個線程直接調用普通方法，看看是不是線程安全的？

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("測試結束");
 }

}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253

運行結果：

線程名：Thread-0，普通方法，運行開始
線程名：Thread-1，同步方法，運行開始
線程：Thread-1，同步方法，運行結束,開始調用普通方法
線程名：Thread-1，普通方法，運行開始
線程：Thread-0，普通方法，運行結束
線程：Thread-1，普通方法，運行結束
線程名：Thread-2，同步方法，運行開始
線程：Thread-2，同步方法，運行結束,開始調用普通方法
線程名：Thread-2，普通方法，運行開始
線程：Thread-2，普通方法，運行結束
測試結束
1234567891011

結果分析：

咱們能夠看出，普通方法被兩個線程並行執行，不是線程安全的。這是爲何呢？

由於若是非同步方法，有任何其餘線程直接調用，而不是僅在調用同步方法時，才調用非同步方法，此時會出現多個線程並行執行非同步方法的狀況，線程就不安全了。

對於同步方法中調用非同步方法時，要想保證線程安全，就必須保證非同步方法的入口，僅出如今同步方法中。但這種控制方式不夠優雅，若被不明狀況的人直接調用非同步方法，就會致使原有的線程同步再也不安全。因此不推薦你們在項目中這樣使用，但咱們要理解這種狀況，而且咱們要用語義明確的、讓人一看就知道這是同步方法的方式，來處理線程安全的問題。

因此，最簡單的方式，是在非同步方法上，也加上synchronized關鍵字，使其變成一個同步方法，這樣就變成了《場景五：兩個線程同時訪問同一個對象的不一樣的同步方法》，這種場景下，你們就很清楚的看到，同一個對象中的兩個同步方法，無論哪一個線程調用，都是線程安全的了。

因此結論是：

兩個線程訪問同一個對象中的同步方法，同步方法又調用一個非同步方法，僅在沒有其餘線程直接調用非同步方法的狀況下，是線程安全的。如有其餘線程直接調用非同步方法，則是線程不安全的。
1

場景六：兩個線程同時訪問同一個對象的不一樣的同步方法

這個場景也是在探討對象鎖的做用範圍，對象鎖的做用範圍是對象中的全部同步方法。因此，當訪問同一個對象中的多個同步方法時，結論是：

兩個線程同時訪問同一個對象的不一樣的同步方法時，是線程安全的。
1
public class Condition5 implements Runnable {
 static Condition5 instance = new Condition5();

 @Override
 public void run() {
  if (Thread.currentThread().getName().equals("Thread-0")) {
   //線程0,執行同步方法method0()
   method0();
  }
  if (Thread.currentThread().getName().equals("Thread-1")) {
   //線程1,執行同步方法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("測試結束");
 }
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546

運行結果：

是線程安全的。

線程名：Thread-1，同步方法1，運行開始
線程：Thread-1，同步方法1，運行結束
線程名：Thread-0，同步方法0，運行開始
線程：Thread-0，同步方法0，運行結束
測試結束
12345

結果分析：

兩個方法（method0()和method1()）的synchronized修飾符，雖沒有指定鎖對象，但默認鎖對象爲this對象爲鎖對象，因此對於同一個實例（instance），兩個線程拿到的鎖是同一把鎖，此時同步方法會串行執行。這也是synchronized關鍵字的可重入性的一種體現。

場景七：兩個線程分別同時訪問靜態synchronized和非靜態synchronized方法

這種場景的本質也是在探討兩個線程獲取的是否是同一把鎖的問題。靜態synchronized方法屬於類鎖，鎖對象是（*.class）對象，非靜態synchronized方法屬於對象鎖中的方法鎖，鎖對象是this對象。兩個線程拿到的是不一樣的鎖，天然不會相互影響。結論：

兩個線程分別同時訪問靜態synchronized和非靜態synchronized方法，線程不安全。
1

代碼實現：

public class Condition6 implements Runnable {
 static Condition6 instance = new Condition6();

 @Override
 public void run() {
  if (Thread.currentThread().getName().equals("Thread-0")) {
   //線程0,執行靜態同步方法method0()
   method0();
  }
  if (Thread.currentThread().getName().equals("Thread-1")) {
   //線程1,執行非靜態同步方法method1()
   method1();
  }
 }

 // 重點：用static synchronized 修飾的方法，屬於類鎖，鎖對象爲（*.class）對象。
 private static 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，運行結束");
 }

 // 重點：synchronized 修飾的方法，屬於方法鎖，鎖對象爲（this）對象。
 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) {
  //問題緣由： 線程1的鎖是類鎖（*.class）對象，線程2的鎖是方法鎖（this）對象,兩個線程的鎖不同，天然不會互相影響，因此會並行執行。
  Thread thread1 = new Thread(instance);
  Thread thread2 = new Thread(instance);
  thread1.start();
  thread2.start();
  while (thread1.isAlive() || thread2.isAlive()) {
  }
  System.out.println("測試結束");
 }
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748

運行結果：

線程名：Thread-0，靜態同步方法0，運行開始
線程名：Thread-1，非靜態同步方法1，運行開始
線程：Thread-1，非靜態同步方法1，運行結束
線程：Thread-0，靜態同步方法0，運行結束
測試結束
12345

場景八：同步方法拋出異常後，JVM會自動釋放鎖的狀況

本場景探討的是synchronized釋放鎖的場景：

只有當同步方法執行完或執行時拋出異常這兩種狀況，纔會釋放鎖。
1

因此，在一個線程的同步方法中出現異常的時候，會釋放鎖，另外一個線程獲得鎖，繼續執行。而不會出現一個線程拋出異常後，另外一個線程一直等待獲取鎖的狀況。這是由於JVM在同步方法拋出異常的時候，會自動釋放鎖對象。

代碼實現：

public class Condition7 implements Runnable {

 private static Condition7 instance = new Condition7();

 @Override
 public void run() {
  if (Thread.currentThread().getName().equals("Thread-0")) {
   //線程0,執行拋異常方法method0()
   method0();
  }
  if (Thread.currentThread().getName().equals("Thread-1")) {
   //線程1,執行正常方法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("測試結束");
 }

}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

運行結果：

線程名：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，運行結束
測試結束
123456789

結果分析：

能夠看出線程仍是串行執行的，說明是線程安全的。並且出現異常後，不會形成死鎖現象，JVM會自動釋放出現異常線程的鎖對象，其餘線程獲取鎖繼續執行。

總結

本文總結了並用代碼實現和驗證了synchronized各類使用場景，以及各類場景發生的緣由和結論。咱們分析的理論基礎都是synchronized關鍵字的鎖對象到底是誰？多個線程之間競爭的是不是同一把鎖？根據這個條件來判斷線程是不是安全的。因此，有了這些場景的分析鍛鍊後，咱們在之後使用多線程編程時，也能夠經過分析鎖對象的方式，判斷出線程是不是安全的，從而避免此類問題的出現。

小編總結了2020面試題，這份面試題的包含的模塊分爲19個模塊，分別是： Java 基礎、容器、多線程、反射、對象拷貝、Java Web 、異常、網絡、設計模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、RabbitMQ、Kafka、Zookeeper、MySQL、Redis、JVM 。

關注公衆號：程序員白楠楠，獲取上述資料。