簡介
本文將介紹7種同步方法的訪問場景,我們來看看着七種情況下,多線程訪問同步方法是否還是線程安全的。這些場景是多線程編程中經常遇到的,而且也是面試時高頻被問到的問題,所以不管是理論還是實踐,這些都是多線程場景必須要掌握的場景。
七種使用場景:
接下來,我們來通過代碼實現,分別判斷以下場景是不是線程安全的,以及原因是什麼。
- 兩個線程同時訪問同一個對象的同步方法
- 兩個線程同時訪問兩個對象的同步方法
- 兩個線程同時訪問(一個或兩個)對象的靜態同步方法
- 兩個線程分別同時訪問(一個或兩個)對象的同步方法和非同步方法
- 兩個線程同時訪問同一個對象的不同的同步方法
- 兩個線程分別同時訪問靜態synchronized和非靜態synchronized方法
- 同步方法拋出異常後,JVM會自動釋放鎖的情況
場景一:兩個線程同時訪問同一個對象的同步方法
分析:這種情況是經典的對象鎖中的方法鎖,兩個線程爭奪同一個對象鎖,所以會相互等待,是線程安全的。
兩個線程同時訪問同一個對象的同步方法,是線程安全的。
我們在前文中已經講過了。代碼和詳細講解在《Java中synchronized實現對象鎖的兩種方式及原理解析》中的第二部分《方法鎖》中,在此就不再重述了。
場景二:兩個線程同時訪問兩個對象的同步方法
這種場景就是對象鎖失效的場景,原因出在訪問的是兩個對象的同步方法,那麼這兩個線程分別持有的兩個線程的鎖,所以是互相不會受限的。加鎖的目的是爲了讓多個線程競爭同一把鎖,而這種情況多個線程之間不再競爭同一把鎖,而是分別持有一把鎖,所以我們的結論是:
兩個線程同時訪問兩個對象的同步方法,是線程不安全的。
代碼驗證:
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("測試結束");
}
}
運行結果:
兩個線程是並行執行的,所以線程不安全。
線程名:Thread-0,運行開始
線程名:Thread-1,運行開始
線程:Thread-0,運行結束
線程:Thread-1,運行結束
測試結束
代碼分析:
問題在此:
兩個線程(thread1、thread2),訪問兩個對象(instance1、instance2)的同步方法(method()),兩個線程都有各自的鎖,不能形成兩個線程競爭一把鎖的局勢,所以這時,synchronized修飾的方法method()和不用synchronized修飾的效果一樣(不信去把synchronized關鍵字去掉,運行結果一樣),所以此時的method()只是個普通方法。
如何解決這個問題:
若要使鎖生效,只需將method()方法用static修飾,這樣就形成了類鎖,多個實例(instance1、instance2)共同競爭一把類鎖,就可以使兩個線程串行執行了。這也就是下一個場景要講的內容。
場景三:兩個線程同時訪問(一個或兩個)對象的靜態同步方法
這個場景解決的是場景二中出現的線程不安全問題,即用類鎖實現:
兩個線程同時訪問(一個或兩個)對象的靜態同步方法,是線程安全的。
關於此方法的代碼實現和詳細講解,參考文章《Java中synchronized實現類鎖的兩種方式及原理解析》中的第二部分《靜態方法鎖的方式實現類鎖》,在此不再重述。
場景四:兩個線程分別同時訪問(一個或兩個)對象的同步方法和非同步方法
這個場景是兩個線程其中一個訪問同步方法,另一個訪問非同步方法,此時程序會不會串行執行呢,也就是說是不是線程安全的呢?
我們可以確定是線程不安全的,如果方法不加synchronized
都是安全的,那就不需要同步方法了。驗證下我們的結論:
兩個線程分別同時訪問(一個或兩個)對象的同步方法和非同步方法,是線程不安全的。
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("測試結束");
}
}
運行結果:
兩個線程是並行執行的,所以是線程不安去的。
線程名: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() {
method0();
}
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() + ",同步方法,運行結束");
// 調用普通方法
method1();
}
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("測試結束");
}
}
運行結果:
線程名:Thread-0,同步方法,運行開始
線程:Thread-0,同步方法,運行結束
線程名:Thread-0,普通方法,運行開始
線程:Thread-0,普通方法,運行結束
線程名:Thread-1,同步方法,運行開始
線程:Thread-1,同步方法,運行結束
線程名:Thread-1,普通方法,運行開始
線程:Thread-1,普通方法,運行結束
測試結束
結果分析:
我們可以看出,方法是串行執行的,所以也是線程安全的。代碼在編譯時,其實就是將非同步方法合併到同步方法中了。所以結論是:
兩個線程訪問同一個對象中的同步方法,同步方法又調用一個非同步方法,是線程安全的。
補充:若是兩個線程訪問多個對象中的同步方法,同步方法又調用一個非同步方法,此時,只需要保證同步方法和普通方法都是靜態方法,也就是都用static
關鍵字修飾,那麼也是線程安全的。因爲是通過類鎖中的靜態方法鎖實現了線程同步(參考:場景三)。
這也是synchronized
關鍵字的特性之可重入性的一種體現,關於可重入性,後續文章再展開探討。
場景五:兩個線程同時訪問同一個對象的不同的同步方法
這個場景也是在探討對象鎖的作用範圍,對象鎖的作用範圍是對象中的所有同步方法。
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("測試結束");
}
}
運行結果:
是線程安全的。
線程名:Thread-1,同步方法1,運行開始
線程:Thread-1,同步方法1,運行結束
線程名:Thread-0,同步方法0,運行開始
線程:Thread-0,同步方法0,運行結束
測試結束
結果分析:
兩個方法(method0()和method1())的synchronized修飾符,雖沒有指定鎖對象,但默認鎖對象爲this對象爲鎖對象,
所以對於同一個實例(instance),兩個線程拿到的鎖是同一把鎖,此時同步方法會串行執行。這也是synchronized
關鍵字的可重入性的一種體現。
場景六:兩個線程分別同時訪問靜態synchronized和非靜態synchronized方法
這種場景的本質也是在探討兩個線程獲取的是不是同一把鎖的問題。靜態synchronized
方法屬於類鎖,鎖對象是(*.class)
對象,非靜態synchronized
方法屬於對象鎖中的方法鎖,鎖對象是this
對象。兩個線程拿到的是不同的鎖,自然不會相互影響。結論:
兩個線程分別同時訪問靜態synchronized和非靜態synchronized方法,線程不安全。
代碼實現:
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("測試結束");
}
運行結果:
線程名:Thread-0,靜態同步方法0,運行開始
線程名:Thread-1,非靜態同步方法1,運行開始
線程:Thread-1,非靜態同步方法1,運行結束
線程:Thread-0,靜態同步方法0,運行結束
測試結束
場景七:同步方法拋出異常後,JVM會自動釋放鎖的情況
本場景探討的是synchronized
釋放鎖的場景:
只有當同步方法執行完或執行時拋出異常這兩種情況,纔會釋放鎖。
所以,在一個線程的同步方法中出現異常的時候,會釋放鎖,另一個線程得到鎖,繼續執行。而不會出現一個線程拋出異常後,另一個線程一直等待獲取鎖的情況。這是因爲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("測試結束");
}
}
運行結果:
線程名: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,運行結束
測試結束
結果分析:
可以看出線程還是串行執行的,說明是線程安全的。而且出現異常後,不會造成死鎖現象,JVM會自動釋放出現異常線程的鎖對象,其他線程獲取鎖繼續執行。
總結
本文總結了並用代碼實現和驗證了synchronized
各種使用場景,以及各種場景發生的原因和結論。我們分析的理論基礎都是synchronized
關鍵字的鎖對象究竟是誰?多個線程之間競爭的是否是同一把鎖?根據這個條件來判斷線程是否是安全的。所以,有了這些場景的分析鍛鍊後,我們在以後使用多線程編程時,也可以通過分析鎖對象的方式,判斷出線程是否是安全的,從而避免此類問題的出現。
本文涵蓋了synchronized
關鍵字的最重要的各種實用場景,也是面試官常常會問到的高頻問題,是一篇值得大家仔細閱讀和親自動手實踐的文章,喜歡本文請點贊和收藏。