2. 程式人生 > 其它 >Java併發程式設計-八鎖問題帶你徹底理解物件鎖和類鎖

Java併發程式設計-八鎖問題帶你徹底理解物件鎖和類鎖

阿新 • • 發佈：2021-01-21

技術標籤：多執行緒併發程式設計Javajava

八鎖問題帶你理解物件鎖和類鎖

8鎖問題演示

1.標準訪問

/*手機類可以發郵件和發簡訊*/
class
 
 Phone{
	public synchronized void sendEmail() throws Exception{
		System.out.println("***sendEmail");
	}
	public synchronized void sendSMS() throws Exception{
		System.out.println("***sendSMS");
	}
}

public class Lock8Demo {
	public static void main(String[] args) throws InterruptedException {
 

		//建立一個資源類
		Phone phone=new Phone();
		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		Thread.sleep(100);
		new Thread(()->{
			try {
				phone.sendSMS();
			} catch (Exception
 
 e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"B").start();
	}
}

在這裡插入圖片描述
標準訪問，先列印郵件還是簡訊.
不一定誰先被列印。取決於CPU的執行情況.啟用他們的是main執行緒，後面誰先被排程，不知道。
為了保證效果，我們在A和B的程式碼之間加thread.sleep(100).此時，可以確保A先被列印。
解釋：
只要一個資源類裡面，不管它有多少個同步方法，只要一個執行緒先訪問了資源類裡面的任何一個同步方法，那麼它鎖的不是這一個方法，鎖的是該方法所在的整個資源類。也就是說，鎖的是物件。它鎖的不是當前的方法。
也就是說，這些synchoronized的方法都屬於同一個資源類裡面，鎖的是整個資源類。

2.在郵件方法中暫停4秒，請問先列印郵件還是簡訊


/*手機類可以發郵件和發簡訊*/
class Phone{
	public synchronized void sendEmail() throws Exception{
		TimeUnit.SECONDS.sleep(4);		//表示暫停4秒，它是一個列舉型別
		System.out.println("***sendEmail");
	}
	public synchronized void sendSMS() throws Exception{
		System.out.println("***sendSMS");
	}
}

public class Lock8Demo {
	public static void main(String[] args) throws InterruptedException {
		//建立一個資源類
		Phone phone=new Phone();
		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		Thread.sleep(100);
		new Thread(()->{
			try {
				phone.sendSMS();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"B").start();
	}
}

先列印郵件。同步方法獲取的phone物件鎖，sleep不會釋放鎖。到了時間會立即執行。所以先列印郵件方法
解釋：
它與問題1類似。
只要一個資源類裡面，不管它有多少個同步方法，只要一個執行緒先訪問了資源類裡面的任何一個同步方法，那麼它鎖的不是這一個方法，鎖的是該方法所在的整個資源類。也就是說，鎖的是物件。它鎖的不是當前的方法。
舉個例子：我和班長要用同一個手機打電話，我肯定要等班長打完電話才能接著打。班長用的過程中停網了一段時間，那我也只能等班長打完。

3.新增普通sayHello方法，請問先列印郵件還是hello

先列印hello

/*手機類可以發郵件和發簡訊*/
class Phone{
	public synchronized void sendEmail() throws Exception{
		TimeUnit.SECONDS.sleep(4);		//表示暫停4秒，它是一個列舉型別
		System.out.println("***sendEmail");
	}
	public synchronized void sendSMS() throws Exception{
		System.out.println("***sendSMS");
	}
	public void sayHello(){
		System.out.println("***sayHello");
	}
}

public class Lock8Demo {
	public static void main(String[] args) throws InterruptedException {
		//建立一個資源類
		Phone phone=new Phone();
		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		Thread.sleep(100);
		new Thread(()->{
			try {
				//phone.sendSMS();
				phone.sayHello();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"B").start();
	}
}

在這裡插入圖片描述
解釋：加個普通方法後發現和同步鎖無關。因此它無需等待同步鎖釋放。
這裡可以舉一個例子。班長用它的手機要打電話。而我要向班長藉手機充電線，這兩個不互斥，因此可以在班長打電話完之前就借走充電線。

4.兩部手機，請問先列印郵件還是簡訊

/*手機類可以發郵件和發簡訊*/
class Phone{
	public synchronized void sendEmail() throws Exception{
		TimeUnit.SECONDS.sleep(4);		//表示暫停4秒，它是一個列舉型別
		System.out.println("***sendEmail");
	}
	public synchronized void sendSMS() throws Exception{
		System.out.println("***sendSMS");
	}
	public void sayHello(){
		System.out.println("***sayHello");
	}
}

public class Lock8Demo {
	public static void main(String[] args) throws InterruptedException {
		//建立一個資源類
		Phone phone=new Phone();
		Phone phone2=new Phone();
		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		Thread.sleep(100);
		new Thread(()->{
			try {
				//phone.sendSMS();
				//phone.sayHello();
				phone2.sendSMS();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"B").start();
	}
}

在這裡插入圖片描述

解釋：這裡可以舉一個例子，班長用它的手機法郵件。我用我自己的手機打電話。那麼誰先誰後就沒有關係。

5.兩個靜態同步方法，同一部手機，請問先列印郵件還是簡訊

/*手機類可以發郵件和發簡訊*/
class Phone{
	public static synchronized void sendEmail() throws Exception{
		TimeUnit.SECONDS.sleep(4);		//表示暫停4秒，它是一個列舉型別
		System.out.println("***sendEmail");
	}
	public static synchronized void sendSMS() throws Exception{
		System.out.println("***sendSMS");
	}
	public void sayHello(){
		System.out.println("***sayHello");
	}
}

public class Lock8Demo {
	public static void main(String[] args) throws InterruptedException {
		//建立一個資源類
		Phone phone=new Phone();
		Phone phone2=new Phone();
		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		Thread.sleep(100);
		new Thread(()->{
			try {
				phone.sendSMS();
				//phone.sayHello();
				//phone2.sendSMS();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"B").start();
	}
}

在這裡插入圖片描述
解釋：可以與問題6一起分析

6.兩個靜態同步方法，兩部手機，請問先列印郵件還是簡訊

/*手機類可以發郵件和發簡訊*/
class Phone{
	public static synchronized void sendEmail() throws Exception{
		TimeUnit.SECONDS.sleep(4);		//表示暫停4秒，它是一個列舉型別
		System.out.println("***sendEmail");
	}
	public static synchronized void sendSMS() throws Exception{
		System.out.println("***sendSMS");
	}
	public void sayHello(){
		System.out.println("***sayHello");
	}
}

public class Lock8Demo {
	public static void main(String[] args) throws InterruptedException {
		//建立一個資源類
		Phone phone=new Phone();
		Phone phone2=new Phone();
		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		Thread.sleep(100);
		new Thread(()->{
			try {
				//phone.sendSMS();
				//phone.sayHello();
				phone2.sendSMS();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"B").start();
	}
}

在這裡插入圖片描述
解析：
static屬於一個類。也就說，他不屬於當前物件this的一個獨立的個體。而是屬於全域性的class。這就要考慮物件鎖和全域性鎖的區別。全域性鎖即類鎖。此時不管是一個phone還是多個phone都來自於同一個類Phone類。現在不管你鎖到了哪個物件，我都要等他釋放完了這個鎖才能使用。

7.1個靜態同步方法，1個普通同步方法，同一部手機，請問先列印郵件還是簡訊

/*手機類可以發郵件和發簡訊*/
class Phone{
	public static synchronized void sendEmail() throws Exception{
		TimeUnit.SECONDS.sleep(4);		//表示暫停4秒，它是一個列舉型別
		System.out.println("***sendEmail");
	}
	public synchronized void sendSMS() throws Exception{
		System.out.println("***sendSMS");
	}
	public void sayHello(){
		System.out.println("***sayHello");
	}
}

public class Lock8Demo {
	public static void main(String[] args) throws InterruptedException {
		//建立一個資源類
		Phone phone=new Phone();
		Phone phone2=new Phone();
		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		Thread.sleep(100);
		new Thread(()->{
			try {
				phone.sendSMS();
				//phone.sayHello();
				//phone2.sendSMS();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"B").start();
	}
}

在這裡插入圖片描述
一個靜態，一個普通。鎖的是同一部手機。靜態方法鎖的是Class.相當於我們鎖了一個校門，一個是普通同步方法，鎖的是當前物件。比如教師普通的們。鎖的物件不一樣。就不衝突

8.1個靜態同步方法，1個普通同步方法，兩部手機，請問先列印郵件還是簡訊

/*手機類可以發郵件和發簡訊*/
class Phone{
	public static synchronized void sendEmail() throws Exception{
		TimeUnit.SECONDS.sleep(4);		//表示暫停4秒，它是一個列舉型別
		System.out.println("***sendEmail");
	}
	public synchronized void sendSMS() throws Exception{
		System.out.println("***sendSMS");
	}
	public void sayHello(){
		System.out.println("***sayHello");
	}
}

public class Lock8Demo {
	public static void main(String[] args) throws InterruptedException {
		//建立一個資源類
		Phone phone=new Phone();
		Phone phone2=new Phone();
		new Thread(()->{
			try {
				phone.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		Thread.sleep(100);
		new Thread(()->{
			try {
				//phone.sendSMS();
				//phone.sayHello();
				phone2.sendSMS();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"B").start();
	}
}

在這裡插入圖片描述

解釋：這個跟上面是一樣的。

8鎖理論解釋

1.一個物件裡面如果有多個syncrhonized方法，某一時刻內，只要有一個執行緒去呼叫其中的一個synchronized方法了，其他的執行緒都只能等待，換句話說，某一時刻內，只能有唯一一個執行緒去訪問這些synchronized方法。
鎖的是當前物件this,被鎖定後，其他的執行緒都不能進入到當前物件的其他synchronized方法

加個普通方法後發現和同步鎖無關。
換乘兩個物件後，不是同一把鎖了，情況立刻發生變化。
都換成靜態同步方法後，情況立刻變化
所有的非靜態同步方法用的都是同一把鎖------例項物件本身

2.synchronized實現同步的基礎：java中的每個物件都可以作為鎖。
具體表現為以下3種形式：

  1. 對於普通同步方法，鎖是當前例項物件
  2. 對於同步方法塊，鎖是synchronized括號裡面配置的物件。
    比如在方法裡寫
    synchronized(this){
    }
  3. 對於靜態同步方法，鎖是當前類的Class物件。

當一個程序試圖訪問同步程式碼塊時，它首先必須得到鎖，退出或丟擲異常必須釋放鎖。
也就是說一個例項物件的非靜態同步方法獲取鎖後，該例項物件的其他非靜態同步方法必須等待獲取鎖的方法釋放鎖後才能獲取鎖。可是別的例項物件的非靜態同步方法因為跟該例項物件的非靜態同步方法用的是不同的鎖，所以無需等待該例項物件已獲取鎖的非靜態同步方法釋放鎖就可以獲取他們自己的鎖。

所有的靜態同步方法用的也是同一把鎖-----類物件本身。
這兩把鎖是兩個不同的物件，所以靜態同步方法與非靜態同步方法之間是不會有競態條件的。（問題78）。即一個鎖class,一個鎖this，兩者不衝突。
但是一旦一個靜態同步方法獲取鎖後，其他的靜態同步方法都必須等待該方法釋放鎖後才能獲取鎖。而不管是同一個例項物件的靜態方法之間，還是不同的例項物件的靜態同步方法之間，只要它們同一個類的例項物件。（問題56）

相關推薦

Java併發程式設計-八鎖問題帶你徹底理解物件鎖和類鎖

技術標籤：多執行緒併發程式設計Javajava 八鎖問題帶你理解物件鎖和類鎖 8鎖問題演示1.標準訪問2.在郵件方法中暫停4秒，請問先列印郵件還是簡訊3.新增普通sayHello方法，請問先列印郵件還是hello4.兩部手機，請

24張圖 | 帶你徹底理解Java中的21種鎖

1、樂觀鎖 樂觀鎖是一種樂觀思想，假定當前環境是讀多寫少，遇到併發寫的概率比較低，讀資料時認為別的執行緒不會正在進行修改（所以沒有上鎖）。寫資料時，判斷當前 與期望值是否相同，如果相同則進行更新（更新

一文帶你徹底理解Java序列化和反序列化

Java序列化是什麼？ Java序列化是指把Java物件轉換為位元組序列的過程，Java反序列化是指把位元組序列恢復為Java物件的過程。

計算機通訊之謎，帶你徹底理解socket網路程式設計（一）

出現一項技術，首先我們弄懂一下，為什麼要出現。那麼為什麼要出現socket這玩意呢？可以很簡單的用一句話來概括：

計算機通訊之謎，帶你徹底理解socket網路程式設計（二）

在《計算機通訊之謎，帶你徹底理解socket網路程式設計（一）》一文裡我們提到了，客戶端傳送了資料了之後，不管服務端還是客戶端都close退出了，也就是說只能傳送一次資料，這顯然不符合實際的用途。那麼該如何更改程

Java併發程式設計：如何防止線上程阻塞與喚醒時死鎖

說到suspend與resume組合有死鎖傾向,一不小心將導致很多問題，甚至導致整個系統崩潰。接著看另外一種解決方案，我們可以使用以物件為目標的阻塞，即利用Object類的wait()和notify()方法實現執行緒阻塞。當執行緒到

Java併發程式設計入門（十一）限流場景和Spring限流器實現

Java極客  |  作者  /  鏗然一葉 這是Java極客的第 39 篇原創文章 一、限流場景

帶你徹底理解 Redis 持久化

帶你徹底理解 Redis 持久化 一、前言 redis作為記憶體資料庫，在我們後端開發中應用是非常多的，尤其是在大流量背景下，redis作為快取資料庫就必不可少了。想了解redis使用場景可以移步至。

一文讓你徹底理解group by和聚合函式

知道group by是進行分組查詢，但是一直覺得對其理解得不夠透徹，在網上扒了一篇文章，我認為寫得非常好。

Java併發程式設計入門（十三）讀寫鎖和快取模板

Java極客  |  作者  /  鏗然一葉 這是Java極客的第 41 篇原創文章 一、讀寫鎖

Java併發程式設計入門（十）鎖優化

Java極客  |  作者  /  鏗然一葉 這是Java極客的第 38 篇原創文章 一、鎖優化

Java併發程式設計入門（九）死鎖和死鎖定位

Java極客  |  作者  /  鏗然一葉 這是Java極客的第 37 篇原創文章 一、死鎖條件

Java併發程式設計入門（十八）再論執行緒安全

Java極客  |  作者  /  鏗然一葉 這是Java極客的第 46 篇原創文章 一、無需加鎖的執行緒安全場景

Java併發程式設計預防死鎖過程詳解

這篇文章主要介紹了Java併發程式設計預防死鎖過程詳解,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

java併發程式設計專題（八）----（JUC）例項講解CountDownLatch

CountDownLatch 是一個非常實用的多執行緒控制工具類。” Count Down ” 在英文中意為倒計數， Latch 為門問的意思。如果翻譯成為倒計數門閥， 我想大家都會覺得不知所云吧! 因此，這裡簡單地稱之為倒計數器。在這裡

淺談Java併發程式設計之Lock鎖和條件變數

簡單使用Lock鎖 Java 5中引入了新的鎖機制——java.util.concurrent.locks中的顯式的互斥鎖：Lock介面，它提供了比synchronized更加廣泛的鎖定操作。Lock介面有3個實現它的類：ReentrantLock、ReetrantReadWriteLock

java併發程式設計系列之原理篇-synchronized與鎖

前言 Java中的鎖都是基於物件的鎖，Java中的每一個物件都可以作為一個鎖，我們常聽到類鎖其實也是物件鎖，因為Java類只有一個class物件（一個Java類可以有多個例項物件，多個例項物件共享這一個Java類）。之所以有鎖

Java併發程式設計如何降低鎖粒度並實現效能優化

在高負載多執行緒應用中效能是非常重要的。為了達到更好的效能，開發者必須意識到併發的重要性。當我們需要使用併發時， 常常有一個資源必須被兩個或多個執行緒共享。

【Java併發程式設計的藝術】Java中的鎖:Lock&AQS

1.Lock介面 鎖是用來控制多個執行緒訪問共享資源的方式。在Java SE5 Lock接口出現之前，通過synchronized實現鎖功能。

JAVA併發程式設計學習筆記07-死鎖

技術標籤：JAVA併發程式設計java多執行緒併發程式設計 JAVA併發程式設計學習筆記07-死鎖