這篇文章主要講解了“Java多線程訪問Synchronized同步方法的使用場(chǎng)景”，文中的講解內(nèi)容簡(jiǎn)單清晰，易于學(xué)習(xí)與理解，下面請(qǐng)大家跟著小編的思路慢慢深入，一起來研究和學(xué)習(xí)“Java多線程訪問Synchronized同步方法的使用場(chǎng)景”吧！
創(chuàng)新互聯(lián)建站-專業(yè)網(wǎng)站定制、快速模板網(wǎng)站建設(shè)、高性價(jià)比辛集網(wǎng)站開發(fā)、企業(yè)建站全套包干低至880元,成熟完善的模板庫,直接使用。一站式辛集網(wǎng)站制作公司更省心,省錢,快速模板網(wǎng)站建設(shè)找我們，業(yè)務(wù)覆蓋辛集地區(qū)。費(fèi)用合理售后完善，十載實(shí)體公司更值得信賴。
本文將介紹7種同步方法的訪問場(chǎng)景，我們來看看這七種情況下，多線程訪問同步方法是否還是線程安全的。這些場(chǎng)景是多線程編程中經(jīng)常遇到的，而且也是面試時(shí)高頻被問到的問題，所以不管是理論還是實(shí)踐，這些都是多線程場(chǎng)景必須要掌握的場(chǎng)景。
接下來，我們來通過代碼實(shí)現(xiàn)，分別判斷以下場(chǎng)景是不是線程安全的，以及原因是什么。
兩個(gè)線程同時(shí)訪問同一個(gè)對(duì)象的同步方法
兩個(gè)線程同時(shí)訪問兩個(gè)對(duì)象的同步方法
兩個(gè)線程同時(shí)訪問（一個(gè)或兩個(gè)）對(duì)象的靜態(tài)同步方法
兩個(gè)線程分別同時(shí)訪問（一個(gè)或兩個(gè)）對(duì)象的同步方法和非同步方法
兩個(gè)線程訪問同一個(gè)對(duì)象中的同步方法，同步方法又調(diào)用一個(gè)非同步方法
兩個(gè)線程同時(shí)訪問同一個(gè)對(duì)象的不同的同步方法
兩個(gè)線程分別同時(shí)訪問靜態(tài)synchronized和非靜態(tài)synchronized方法
同步方法拋出異常后，JVM會(huì)自動(dòng)釋放鎖的情況
分析：這種情況是經(jīng)典的對(duì)象鎖中的方法鎖，兩個(gè)線程爭(zhēng)奪同一個(gè)對(duì)象鎖，所以會(huì)相互等待，是線程安全的。
兩個(gè)線程同時(shí)訪問同一個(gè)對(duì)象的同步方法，是線程安全的。 1
我們?cè)谇拔闹幸呀?jīng)講過了。代碼和詳細(xì)講解在《Java中synchronized實(shí)現(xiàn)對(duì)象鎖的兩種方式及原理解析》中的第二部分《方法鎖》中，在此就不再重述了。
這種場(chǎng)景就是對(duì)象鎖失效的場(chǎng)景，原因出在訪問的是兩個(gè)對(duì)象的同步方法，那么這兩個(gè)線程分別持有的兩個(gè)線程的鎖，所以是互相不會(huì)受限的。加鎖的目的是為了讓多個(gè)線程競(jìng)爭(zhēng)同一把鎖，而這種情況多個(gè)線程之間不再競(jìng)爭(zhēng)同一把鎖，而是分別持有一把鎖，所以我們的結(jié)論是：
兩個(gè)線程同時(shí)訪問兩個(gè)對(duì)象的同步方法，是線程不安全的。 1
重慶分公司
重慶分公司
public class Condition2 implements Runnable {
// 創(chuàng)建兩個(gè)不同的對(duì)象
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() + "，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，運(yùn)行結(jié)束");
}
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("測(cè)試結(jié)束");
}
}
123456789101112131415161718192021222324252627282930兩個(gè)線程是并行執(zhí)行的，所以線程不安全。
關(guān)注公眾號(hào)：程序員白楠楠，領(lǐng)取2020年末總結(jié)面試題
線程名：Thread-0，運(yùn)行開始 線程名：Thread-1，運(yùn)行開始 線程：Thread-0，運(yùn)行結(jié)束 線程：Thread-1，運(yùn)行結(jié)束 測(cè)試結(jié)束 12345
「問題在此：」兩個(gè)線程（thread1、thread2），訪問兩個(gè)對(duì)象（instance1、instance2）的同步方法（method()）,兩個(gè)線程都有各自的鎖，不能形成兩個(gè)線程競(jìng)爭(zhēng)一把鎖的局勢(shì)，所以這時(shí)，synchronized修飾的方法method()和不用synchronized修飾的效果一樣（不信去把synchronized關(guān)鍵字去掉，運(yùn)行結(jié)果一樣），所以此時(shí)的method()只是個(gè)普通方法。
「如何解決這個(gè)問題：」若要使鎖生效，只需將method()方法用static修飾，這樣就形成了類鎖，多個(gè)實(shí)例（instance1、instance2）共同競(jìng)爭(zhēng)一把類鎖，就可以使兩個(gè)線程串行執(zhí)行了。這也就是下一個(gè)場(chǎng)景要講的內(nèi)容。
這個(gè)場(chǎng)景解決的是場(chǎng)景二中出現(xiàn)的線程不安全問題，即用類鎖實(shí)現(xiàn)：
兩個(gè)線程同時(shí)訪問（一個(gè)或兩個(gè)）對(duì)象的靜態(tài)同步方法，是線程安全的。 1
關(guān)于此方法的代碼實(shí)現(xiàn)和詳細(xì)講解，參考文章《Java中synchronized實(shí)現(xiàn)類鎖的兩種方式及原理解析》中的第二部分《靜態(tài)方法鎖的方式實(shí)現(xiàn)類鎖》，在此不再重述。
這個(gè)場(chǎng)景是兩個(gè)線程其中一個(gè)訪問同步方法，另一個(gè)訪問非同步方法，此時(shí)程序會(huì)不會(huì)串行執(zhí)行呢，也就是說是不是線程安全的呢？我們可以確定是線程不安全的，如果方法不加synchronized都是安全的，那就不需要同步方法了。驗(yàn)證下我們的結(jié)論：
兩個(gè)線程分別同時(shí)訪問（一個(gè)或兩個(gè)）對(duì)象的同步方法和非同步方法，是線程不安全的。
1
public class Condition4 implements Runnable {
static Condition4 instance = new Condition4();
@Override
public void run() {
//兩個(gè)線程訪問同步方法和非同步方法
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() + "，同步方法，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，同步方法，運(yùn)行結(jié)束");
}
// 普通方法
private void method1() {
System.out.println("線程名：" + Thread.currentThread().getName() + "，普通方法，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，普通方法，運(yùn)行結(jié)束");
}
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("測(cè)試結(jié)束");
}
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950兩個(gè)線程是并行執(zhí)行的，所以是線程不安全的。
線程名：Thread-0，同步方法，運(yùn)行開始 線程名：Thread-1，普通方法，運(yùn)行開始 線程：Thread-0，同步方法，運(yùn)行結(jié)束 線程：Thread-1，普通方法，運(yùn)行結(jié)束 測(cè)試結(jié)束 12345
「問題在于此：」 method1沒有被synchronized修飾，所以不會(huì)受到鎖的影響。即便是在同一個(gè)對(duì)象中，當(dāng)然在多個(gè)實(shí)例中，更不會(huì)被鎖影響了。結(jié)論：
非同步方法不受其它由synchronized修飾的同步方法影響 1
你可能想到一個(gè)類似場(chǎng)景：多個(gè)線程訪問同一個(gè)對(duì)象中的同步方法，同步方法又調(diào)用一個(gè)非同步方法，這個(gè)場(chǎng)景會(huì)是線程安全的嗎？
我們來實(shí)驗(yàn)下這個(gè)場(chǎng)景，用兩個(gè)線程調(diào)用同步方法，在同步方法中調(diào)用普通方法；再用一個(gè)線程直接調(diào)用普通方法，看看是否是線程安全的？
public class Condition8 implements Runnable {
static Condition8 instance = new Condition8();
@Override
public void run() {
if (Thread.currentThread().getName().equals("Thread-0")) {
//直接調(diào)用普通方法
method2();
} else {
// 先調(diào)用同步方法，在同步方法內(nèi)調(diào)用普通方法
method1();
}
}
// 同步方法
private static synchronized void method1() {
System.out.println("線程名：" + Thread.currentThread().getName() + "，同步方法，運(yùn)行開始");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，同步方法，運(yùn)行結(jié)束,開始調(diào)用普通方法");
method2();
}
// 普通方法
private static void method2() {
System.out.println("線程名：" + Thread.currentThread().getName() + "，普通方法，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，普通方法，運(yùn)行結(jié)束");
}
public static void main(String[] args) {
// 此線程直接調(diào)用普通方法
Thread thread0 = new Thread(instance);
// 這兩個(gè)線程直接調(diào)用同步方法
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("測(cè)試結(jié)束");
}
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253線程名：Thread-0，普通方法，運(yùn)行開始 線程名：Thread-1，同步方法，運(yùn)行開始 線程：Thread-1，同步方法，運(yùn)行結(jié)束,開始調(diào)用普通方法 線程名：Thread-1，普通方法，運(yùn)行開始 線程：Thread-0，普通方法，運(yùn)行結(jié)束 線程：Thread-1，普通方法，運(yùn)行結(jié)束 線程名：Thread-2，同步方法，運(yùn)行開始 線程：Thread-2，同步方法，運(yùn)行結(jié)束,開始調(diào)用普通方法 線程名：Thread-2，普通方法，運(yùn)行開始 線程：Thread-2，普通方法，運(yùn)行結(jié)束 測(cè)試結(jié)束 1234567891011
我們可以看出，普通方法被兩個(gè)線程并行執(zhí)行，不是線程安全的。這是為什么呢？
因?yàn)槿绻峭椒椒ǎ腥魏纹渌€程直接調(diào)用，而不是僅在調(diào)用同步方法時(shí)，才調(diào)用非同步方法，此時(shí)會(huì)出現(xiàn)多個(gè)線程并行執(zhí)行非同步方法的情況，線程就不安全了。
對(duì)于同步方法中調(diào)用非同步方法時(shí)，要想保證線程安全，就必須保證非同步方法的入口，僅出現(xiàn)在同步方法中。但這種控制方式不夠優(yōu)雅，若被不明情況的人直接調(diào)用非同步方法，就會(huì)導(dǎo)致原有的線程同步不再安全。所以不推薦大家在項(xiàng)目中這樣使用，但我們要理解這種情況，并且我們要用語義明確的、讓人一看就知道這是同步方法的方式，來處理線程安全的問題。
所以，最簡(jiǎn)單的方式，是在非同步方法上，也加上synchronized關(guān)鍵字，使其變成一個(gè)同步方法，這樣就變成了《場(chǎng)景五：兩個(gè)線程同時(shí)訪問同一個(gè)對(duì)象的不同的同步方法》，這種場(chǎng)景下，大家就很清楚的看到，同一個(gè)對(duì)象中的兩個(gè)同步方法，不管哪個(gè)線程調(diào)用，都是線程安全的了。
所以結(jié)論是：
兩個(gè)線程訪問同一個(gè)對(duì)象中的同步方法，同步方法又調(diào)用一個(gè)非同步方法，僅在沒有其他線程直接調(diào)用非同步方法的情況下，是線程安全的。若有其他線程直接調(diào)用非同步方法，則是線程不安全的。 1
這個(gè)場(chǎng)景也是在探討對(duì)象鎖的作用范圍，對(duì)象鎖的作用范圍是對(duì)象中的所有同步方法。所以，當(dāng)訪問同一個(gè)對(duì)象中的多個(gè)同步方法時(shí)，結(jié)論是：
兩個(gè)線程同時(shí)訪問同一個(gè)對(duì)象的不同的同步方法時(shí)，是線程安全的。
1
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，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，同步方法0，運(yùn)行結(jié)束");
}
private synchronized void method1() {
System.out.println("線程名：" + Thread.currentThread().getName() + "，同步方法1，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，同步方法1，運(yùn)行結(jié)束");
}
//運(yùn)行結(jié)果:串行
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("測(cè)試結(jié)束");
}
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546是線程安全的。
線程名：Thread-1，同步方法1，運(yùn)行開始 線程：Thread-1，同步方法1，運(yùn)行結(jié)束 線程名：Thread-0，同步方法0，運(yùn)行開始 線程：Thread-0，同步方法0，運(yùn)行結(jié)束 測(cè)試結(jié)束 12345
兩個(gè)方法（method0()和method1()）的synchronized修飾符，雖沒有指定鎖對(duì)象，但默認(rèn)鎖對(duì)象為this對(duì)象為鎖對(duì)象， 所以對(duì)于同一個(gè)實(shí)例（instance），兩個(gè)線程拿到的鎖是同一把鎖，此時(shí)同步方法會(huì)串行執(zhí)行。這也是synchronized關(guān)鍵字的可重入性的一種體現(xiàn)。
這種場(chǎng)景的本質(zhì)也是在探討兩個(gè)線程獲取的是不是同一把鎖的問題。靜態(tài)synchronized方法屬于類鎖，鎖對(duì)象是（*.class）對(duì)象，非靜態(tài)synchronized方法屬于對(duì)象鎖中的方法鎖，鎖對(duì)象是this對(duì)象。兩個(gè)線程拿到的是不同的鎖，自然不會(huì)相互影響。結(jié)論：
兩個(gè)線程分別同時(shí)訪問靜態(tài)synchronized和非靜態(tài)synchronized方法，線程不安全。 1
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();
}
}
// 重點(diǎn)：用static synchronized 修飾的方法，屬于類鎖，鎖對(duì)象為（*.class）對(duì)象。
private static synchronized void method0() {
System.out.println("線程名：" + Thread.currentThread().getName() + "，靜態(tài)同步方法0，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，靜態(tài)同步方法0，運(yùn)行結(jié)束");
}
// 重點(diǎn)：synchronized 修飾的方法，屬于方法鎖，鎖對(duì)象為（this）對(duì)象。
private synchronized void method1() {
System.out.println("線程名：" + Thread.currentThread().getName() + "，非靜態(tài)同步方法1，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，非靜態(tài)同步方法1，運(yùn)行結(jié)束");
}
//運(yùn)行結(jié)果:并行
public static void main(String[] args) {
//問題原因： 線程1的鎖是類鎖（*.class）對(duì)象，線程2的鎖是方法鎖（this）對(duì)象,兩個(gè)線程的鎖不一樣，自然不會(huì)互相影響，所以會(huì)并行執(zhí)行。
Thread thread1 = new Thread(instance);
Thread thread2 = new Thread(instance);
thread1.start();
thread2.start();
while (thread1.isAlive() || thread2.isAlive()) {
}
System.out.println("測(cè)試結(jié)束");
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748線程名：Thread-0，靜態(tài)同步方法0，運(yùn)行開始 線程名：Thread-1，非靜態(tài)同步方法1，運(yùn)行開始 線程：Thread-1，非靜態(tài)同步方法1，運(yùn)行結(jié)束 線程：Thread-0，靜態(tài)同步方法0，運(yùn)行結(jié)束 測(cè)試結(jié)束 12345
本場(chǎng)景探討的是synchronized釋放鎖的場(chǎng)景：
只有當(dāng)同步方法執(zhí)行完或執(zhí)行時(shí)拋出異常這兩種情況，才會(huì)釋放鎖。 1
所以，在一個(gè)線程的同步方法中出現(xiàn)異常的時(shí)候，會(huì)釋放鎖，另一個(gè)線程得到鎖，繼續(xù)執(zhí)行。而不會(huì)出現(xiàn)一個(gè)線程拋出異常后，另一個(gè)線程一直等待獲取鎖的情況。這是因?yàn)镴VM在同步方法拋出異常的時(shí)候，會(huì)自動(dòng)釋放鎖對(duì)象。
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() + "，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//同步方法中，當(dāng)拋出異常時(shí)，JVM會(huì)自動(dòng)釋放鎖，不需要手動(dòng)釋放，其他線程即可獲取到該鎖
System.out.println("線程名：" + Thread.currentThread().getName() + "，拋出異常，釋放鎖");
throw new RuntimeException();
}
private synchronized void method1() {
System.out.println("線程名：" + Thread.currentThread().getName() + "，運(yùn)行開始");
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程：" + Thread.currentThread().getName() + "，運(yùn)行結(jié)束");
}
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("測(cè)試結(jié)束");
}
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950線程名：Thread-0，運(yùn)行開始 線程名：Thread-0，拋出異常，釋放鎖 線程名：Thread-1，運(yùn)行開始 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，運(yùn)行結(jié)束 測(cè)試結(jié)束 123456789
可以看出線程還是串行執(zhí)行的，說明是線程安全的。而且出現(xiàn)異常后，不會(huì)造成死鎖現(xiàn)象，JVM會(huì)自動(dòng)釋放出現(xiàn)異常線程的鎖對(duì)象，其他線程獲取鎖繼續(xù)執(zhí)行。
感謝各位的閱讀，以上就是“Java多線程訪問Synchronized同步方法的使用場(chǎng)景”的內(nèi)容了，經(jīng)過本文的學(xué)習(xí)后，相信大家對(duì)Java多線程訪問Synchronized同步方法的使用場(chǎng)景這一問題有了更深刻的體會(huì)，具體使用情況還需要大家實(shí)踐驗(yàn)證。這里是創(chuàng)新互聯(lián)，小編將為大家推送更多相關(guān)知識(shí)點(diǎn)的文章，歡迎關(guān)注！
