特黄AAAAAAAA片免费直播,人人色人人射,太湾黄色一级网,久久成人网豆花视频,A片网站在线免费观看,翔田千里av,五月天婷婷色综合,一级A片亲子乱中文

點(diǎn)擊上方藍(lán)色字體，選擇“標(biāo)星公眾號”

優(yōu)質(zhì)文章，第一時間送達(dá)

簡介

本文將介紹8種同步方法的訪問場景，我們來看看著八種情況下，多線程訪問同步方法是否還是線程安全的。這些場景是多線程編程中經(jīng)常遇到的，而且也是面試時高頻被問到的問題，所以不管是理論還是實(shí)踐，這些都是多線程場景必須要掌握的場景。

八種使用場景：

接下來，我們來通過代碼實(shí)現(xiàn)，分別判斷以下場景是不是線程安全的，以及原因是什么。

兩個線程同時訪問同一個對象的同步方法
兩個線程同時訪問兩個對象的同步方法
兩個線程同時訪問（一個或兩個）對象的靜態(tài)同步方法
兩個線程分別同時訪問（一個或兩個）對象的同步方法和非同步方法
兩個線程訪問同一個對象中的同步方法，同步方法又調(diào)用一個非同步方法
兩個線程同時訪問同一個對象的不同的同步方法
兩個線程分別同時訪問靜態(tài)synchronized和非靜態(tài)synchronized方法
同步方法拋出異常后，JVM會自動釋放鎖的情況

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

分析：這種情況是經(jīng)典的對象鎖中的方法鎖，兩個線程爭奪同一個對象鎖，所以會相互等待，是線程安全的。

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

我們在前文中已經(jīng)講過了。代碼和詳細(xì)講解在《Java中synchronized實(shí)現(xiàn)對象鎖的兩種方式及原理解析》中的第二部分《方法鎖》中，在此就不再重述了。

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

這種場景就是對象鎖失效的場景，原因出在訪問的是兩個對象的同步方法，那么這兩個線程分別持有的兩個線程的鎖，所以是互相不會受限的。加鎖的目的是為了讓多個線程競爭同一把鎖，而這種情況多個線程之間不再競爭同一把鎖，而是分別持有一把鎖，所以我們的結(jié)論是：

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

代碼驗(yàn)證：

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() + "，運(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("測試結(jié)束");
 }
}

運(yùn)行結(jié)果：

兩個線程是并行執(zhí)行的，所以線程不安全。

線程名：Thread-0，運(yùn)行開始
線程名：Thread-1，運(yùn)行開始
線程：Thread-0，運(yùn)行結(jié)束
線程：Thread-1，運(yùn)行結(jié)束
測試結(jié)束

代碼分析：

問題在此：
兩個線程（thread1、thread2），訪問兩個對象（instance1、instance2）的同步方法（method()）,兩個線程都有各自的鎖，不能形成兩個線程競爭一把鎖的局勢，所以這時，synchronized修飾的方法method()和不用synchronized修飾的效果一樣（不信去把synchronized關(guān)鍵字去掉，運(yùn)行結(jié)果一樣），所以此時的method()只是個普通方法。

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

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

這個場景解決的是場景二中出現(xiàn)的線程不安全問題，即用類鎖實(shí)現(xiàn)：

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

關(guān)于此方法的代碼實(shí)現(xiàn)和詳細(xì)講解，參考文章《Java中synchronized實(shí)現(xiàn)類鎖的兩種方式及原理解析》中的第二部分《靜態(tài)方法鎖的方式實(shí)現(xiàn)類鎖》，在此不再重述。

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

這個場景是兩個線程其中一個訪問同步方法，另一個訪問非同步方法，此時程序會不會串行執(zhí)行呢，也就是說是不是線程安全的呢？
我們可以確定是線程不安全的，如果方法不加synchronized都是安全的，那就不需要同步方法了。驗(yàn)證下我們的結(jié)論：

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

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() + "，同步方法，運(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("測試結(jié)束");
 }

}

運(yùn)行結(jié)果：

兩個線程是并行執(zhí)行的，所以是線程不安去的。

線程名：Thread-0，同步方法，運(yùn)行開始
線程名：Thread-1，普通方法，運(yùn)行開始
線程：Thread-0，同步方法，運(yùn)行結(jié)束
線程：Thread-1，普通方法，運(yùn)行結(jié)束
測試結(jié)束

結(jié)果分析

問題在于此： method1沒有被synchronized修飾，所以不會受到鎖的影響。即便是在同一個對象中，當(dāng)然在多個實(shí)例中，更不會被鎖影響了。結(jié)論：

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

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

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

我們來實(shí)驗(yàn)下這個場景，用兩個線程調(diào)用同步方法，在同步方法中調(diào)用普通方法；再用一個線程直接調(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);
  // 這兩個線程直接調(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("測試結(jié)束");
 }

}

運(yùn)行結(jié)果：

線程名：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é)束
測試結(jié)束

結(jié)果分析：

我們可以看出，普通方法被兩個線程并行執(zhí)行，不是線程安全的。這是為什么呢？

因?yàn)槿绻峭椒椒ǎ腥魏纹渌€程直接調(diào)用，而不是僅在調(diào)用同步方法時，才調(diào)用非同步方法，此時會出現(xiàn)多個線程并行執(zhí)行非同步方法的情況，線程就不安全了。

對于同步方法中調(diào)用非同步方法時，要想保證線程安全，就必須保證非同步方法的入口，僅出現(xiàn)在同步方法中。但這種控制方式不夠優(yōu)雅，若被不明情況的人直接調(diào)用非同步方法，就會導(dǎo)致原有的線程同步不再安全。所以不推薦大家在項(xiàng)目中這樣使用，但我們要理解這種情況，并且我們要用語義明確的、讓人一看就知道這是同步方法的方式，來處理線程安全的問題。

所以，最簡單的方式，是在非同步方法上，也加上synchronized關(guān)鍵字，使其變成一個同步方法，這樣就變成了《場景五：兩個線程同時訪問同一個對象的不同的同步方法》，這種場景下，大家就很清楚的看到，同一個對象中的兩個同步方法，不管哪個線程調(diào)用，都是線程安全的了。

所以結(jié)論是：

兩個線程訪問同一個對象中的同步方法，同步方法又調(diào)用一個非同步方法，僅在沒有其他線程直接調(diào)用非同步方法的情況下，是線程安全的。若有其他線程直接調(diào)用非同步方法，則是線程不安全的。

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

這個場景也是在探討對象鎖的作用范圍，對象鎖的作用范圍是對象中的所有同步方法。所以，當(dāng)訪問同一個對象中的多個同步方法時，結(jié)論是：

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

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

運(yùn)行結(jié)果：

是線程安全的。

線程名：Thread-1，同步方法1，運(yùn)行開始
線程：Thread-1，同步方法1，運(yùn)行結(jié)束
線程名：Thread-0，同步方法0，運(yùn)行開始
線程：Thread-0，同步方法0，運(yùn)行結(jié)束
測試結(jié)束

結(jié)果分析：

兩個方法（method0()和method1()）的synchronized修飾符，雖沒有指定鎖對象，但默認(rèn)鎖對象為this對象為鎖對象，
所以對于同一個實(shí)例（instance），兩個線程拿到的鎖是同一把鎖，此時同步方法會串行執(zhí)行。這也是synchronized關(guān)鍵字的可重入性的一種體現(xiàn)。

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

這種場景的本質(zhì)也是在探討兩個線程獲取的是不是同一把鎖的問題。靜態(tài)synchronized方法屬于類鎖，鎖對象是（*.class）對象，非靜態(tài)synchronized方法屬于對象鎖中的方法鎖，鎖對象是this對象。兩個線程拿到的是不同的鎖，自然不會相互影響。結(jié)論：

兩個線程分別同時訪問靜態(tài)synchronized和非靜態(tài)synchronized方法，線程不安全。

代碼實(shí)現(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();
  }
 }

 // 重點(diǎn)：用static synchronized 修飾的方法，屬于類鎖，鎖對象為（*.class）對象。
 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 修飾的方法，屬于方法鎖，鎖對象為（this）對象。
 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）對象，線程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("測試結(jié)束");
 }

運(yùn)行結(jié)果：

線程名：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é)束
測試結(jié)束

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

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

只有當(dāng)同步方法執(zhí)行完或執(zhí)行時拋出異常這兩種情況，才會釋放鎖。

所以，在一個線程的同步方法中出現(xiàn)異常的時候，會釋放鎖，另一個線程得到鎖，繼續(xù)執(zhí)行。而不會出現(xiàn)一個線程拋出異常后，另一個線程一直等待獲取鎖的情況。這是因?yàn)镴VM在同步方法拋出異常的時候，會自動釋放鎖對象。

代碼實(shí)現(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() + "，運(yùn)行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  //同步方法中，當(dāng)拋出異常時，JVM會自動釋放鎖，不需要手動釋放，其他線程即可獲取到該鎖
  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("測試結(jié)束");
 }

}

運(yùn)行結(jié)果：

線程名：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é)束
測試結(jié)束

結(jié)果分析：

可以看出線程還是串行執(zhí)行的，說明是線程安全的。而且出現(xiàn)異常后，不會造成死鎖現(xiàn)象，JVM會自動釋放出現(xiàn)異常線程的鎖對象，其他線程獲取鎖繼續(xù)執(zhí)行。

總結(jié)

本文總結(jié)了并用代碼實(shí)現(xiàn)和驗(yàn)證了synchronized各種使用場景，以及各種場景發(fā)生的原因和結(jié)論。我們分析的理論基礎(chǔ)都是synchronized關(guān)鍵字的鎖對象究竟是誰？多個線程之間競爭的是否是同一把鎖？根據(jù)這個條件來判斷線程是否是安全的。所以，有了這些場景的分析鍛煉后，我們在以后使用多線程編程時，也可以通過分析鎖對象的方式，判斷出線程是否是安全的，從而避免此類問題的出現(xiàn)。

作者 | 大腦補(bǔ)丁

來源 | https://blog.csdn.net/x541211190/article/details/106272922

IDEA性能優(yōu)化！
一步一步帶你理解Java8 JVM調(diào)優(yōu)
Git常用命令超級詳細(xì)
MD5算法詳解
分布式系統(tǒng)中，如何保證數(shù)據(jù)一致性？

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

簡介

八種使用場景：

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

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

代碼驗(yàn)證：

運(yùn)行結(jié)果：

代碼分析：

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

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

運(yùn)行結(jié)果：

結(jié)果分析

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

運(yùn)行結(jié)果：

結(jié)果分析：

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

運(yùn)行結(jié)果：

結(jié)果分析：

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

代碼實(shí)現(xiàn)：

運(yùn)行結(jié)果：

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

代碼實(shí)現(xiàn)：

運(yùn)行結(jié)果：

結(jié)果分析：

總結(jié)

IDEA性能優(yōu)化！

一步一步帶你理解Java8 JVM調(diào)優(yōu)

Git常用命令超級詳細(xì)

MD5算法詳解

分布式系統(tǒng)中，如何保證數(shù)據(jù)一致性？