2. 程式人生 > >Java類鎖和物件鎖實踐

Java類鎖和物件鎖實踐

阿新 • • 發佈：2018-12-22

感謝［jiehao］同學的投稿，投稿可將文章傳送到[email protected]

類鎖和物件鎖是否會衝突？物件鎖和私有鎖是否會衝突？通過例項來進行說明。

一、相關約定

為了明確後文的描述，先對本文涉及到的鎖的相關定義作如下約定：

1. 類鎖：在程式碼中的方法上加了static和synchronized的鎖，或者synchronized(xxx.class）的程式碼段，如下文中的increament()；

2.物件鎖：在程式碼中的方法上加了synchronized的鎖，或者synchronized(this）的程式碼段，如下文中的synOnMethod()和synInMethod()；

3.私有鎖：在類內部宣告一個私有屬性如private Object lock，在需要加鎖的程式碼段synchronized(lock），如下文中的synMethodWithObj()。

二、測試程式碼

1.編寫一個啟動類ObjectLock

public class ObjectLock {
	public static void main(String[] args) {
		System.out.println("start time = " + System.currentTimeMillis()+"ms");
		LockTestClass test = new LockTestClass();
		for (int i = 0; i < 3; i++) {
			Thread thread = new ObjThread(test, i);
			thread.start();
		}
	}
}

2.編寫一個執行緒類ObjThread，用於啟動同步方法（注意它的run方法可能會調整以進行不同的測試）

public class ObjThread extends Thread {
	LockTestClass lock;
	int i = 0;

	public ObjThread(LockTestClass lock, int i) {
		this.lock = lock;
		this.i = i;
	}

	public void run() {
		//無鎖方法
//		lock.noSynMethod(this.getId(),this);
		//物件鎖方法1，採用synchronized synInMethod的方式
		lock.synInMethod();
		//物件鎖方法2，採用synchronized(this)的方式
//		lock.synOnMethod();
		//私有鎖方法，採用synchronized(object)的方式
//		lock.synMethodWithObj();
		//類鎖方法，採用static synchronized increment的方式
		LockTestClass.increment();
	}
}

3.再編寫一個鎖的測試類LockTestClass，包括各種加鎖方法

public class LockTestClass {
	//用於類鎖計數
	private static int i = 0;
    //私有鎖
	private Object object = new Object();

	/**
	 * &lt;p&gt;
	 * 無鎖方法
	 *
	 * @param threadID
	 * @param thread
	 */
	public void noSynMethod(long threadID, ObjThread thread) {
		System.out.println("nosyn: class obj is " + thread + ", threadId is"
				+ threadID);
	}

	/**
	 * 物件鎖方法1
	 */
	public synchronized void synOnMethod() {
		System.out.println("synOnMethod begins" + ", time = "
				+ System.currentTimeMillis() + "ms");
		try {
			Thread.sleep(2000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("synOnMethod ends");
	}

	/**
	 * 物件鎖方法2,採用synchronized (this)來加鎖
	 */
	public void synInMethod() {
		synchronized (this) {
			System.out.println("synInMethod begins" + ", time = "
					+ System.currentTimeMillis() + "ms");
			try {
				Thread.sleep(2000L);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("synInMethod ends");
		}

	}

	/**
	 * 物件鎖方法3
	 */
	public void synMethodWithObj() {
		synchronized (object) {
			System.out.println("synMethodWithObj begins" + ", time = "
					+ System.currentTimeMillis() + "ms");
			try {
				Thread.sleep(2000L);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("synMethodWithObj ends");
		}
	}

	/**
	 * 類鎖
	 */
	public static synchronized void increament() {
		System.out.println("class synchronized. i = " + i + ", time = "
				+ System.currentTimeMillis() + "ms");
		i++;
		try {
			Thread.sleep(2000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		 System.out.println("class synchronized ends.");
	}

}

三、測試結果

1.測試類鎖和物件鎖，ObjectThread的run方法修改如下：

public void run() {
		//無鎖方法
//		lock.noSynMethod(this.getId(),this);
		//物件鎖方法1，採用synchronized synInMethod的方式
		lock.synInMethod();
		//物件鎖方法2，採用synchronized(this)的方式
//		lock.synOnMethod();
		//私有鎖方法，採用synchronized(object)的方式
//		lock.synMethodWithObj();
		//類鎖方法，採用static synchronized increment的方式
		LockTestClass.increament();
	}

終端輸出：

start time = 1413101360231ms
synInMethod begins, time = 1413101360233ms
synInMethod ends
class synchronized. i = 0, time = 1413101362233ms
synInMethod begins, time = 1413101362233ms
class synchronized ends.
synInMethod ends
class synchronized. i = 1, time = 1413101364233ms
synInMethod begins, time = 1413101364233ms
class synchronized ends.
synInMethod ends
class synchronized. i = 2, time = 1413101366234ms
class synchronized ends.

可以看到物件鎖方法(synInMothod）第一次啟動時比類鎖方法（increament)快2秒，這是因為在synInMehtod執行時sleep了2秒再執行的increament，而這兩個方法共用一個執行緒，所以會慢2秒，如果increament在run中放到synInMethod前面，那麼第一次啟動時就是increament快2秒。
而當類鎖方法啟動時，另一個執行緒時的物件鎖方法也幾乎同時啟動，說明二者使用的並非同一個鎖，不會產生競爭。
結論：類鎖和物件鎖不會產生競爭，二者的加鎖方法不會相互影響。

2.私有鎖和物件鎖，ObjectThread的run方法修改如下：

public void run() {
		//無鎖方法
//		lock.noSynMethod(this.getId(),this);
		//物件鎖方法1，採用synchronized synInMethod的方式
		lock.synInMethod();
		//物件鎖方法2，採用synchronized(this)的方式
//		lock.synOnMethod();
		//私有鎖方法，採用synchronized(object)的方式
		lock.synMethodWithObj();
		//類鎖方法，採用static synchronized increment的方式
//		LockTestClass.increament();
	}

終端輸出：

start time = 1413121912406ms
synInMethod begins, time = 1413121912407ms.
synInMethod ends.
synMethodWithObj begins, time = 1413121914407ms
synInMethod begins, time = 1413121914407ms.
synInMethod ends.
synMethodWithObj ends
synInMethod begins, time = 1413121916407ms.
synMethodWithObj begins, time = 1413121916407ms
synInMethod ends.
synMethodWithObj ends
synMethodWithObj begins, time = 1413121918407ms
synMethodWithObj ends

和類鎖和物件鎖非常類似。

結論：私有鎖和物件鎖也不會產生競爭，二者的加鎖方法不會相互影響。

3.synchronized直接加在方法上和synchronized(this)，ObjectThread的run方法修改如下： 
public void run() {
		//無鎖方法
//		lock.noSynMethod(this.getId(),this);
		//物件鎖方法1，採用synchronized synInMethod的方式
		lock.synInMethod();
		//物件鎖方法2，採用synchronized(this)的方式
		lock.synOnMethod();
		//私有鎖方法，採用synchronized(object)的方式
//		lock.synMethodWithObj();
		//類鎖方法，採用static synchronized increment的方式
//		LockTestClass.increament();
	}

終端輸出：

start time = 1413102913278ms
synInMethod begins, time = 1413102913279ms
synInMethod ends
synInMethod begins, time = 1413102915279ms
synInMethod ends
synOnMethod begins, time = 1413102917279ms
synOnMethod ends
synInMethod begins, time = 1413102919279ms
synInMethod ends
synOnMethod begins, time = 1413102921279ms
synOnMethod ends
synOnMethod begins, time = 1413102923279ms
synOnMethod ends

       可以看到，二者嚴格地序列輸出（當然再次執行時先執行synInMethod還是先執行synOnMethod並不是確定的，取決於誰獲得了鎖）。

    結論：synchronized直接加在方法上和synchronized(this)都是對當前物件加鎖，二者的加鎖方法夠成了競爭關係，同一時刻只能有一個方法能執行。

四、參考資料：


混跡於58同城，對java、開源感興趣。
個人部落格：http://jiehao.iteye.com/

Latest posts by zhaojianhua

相關推薦

Java類鎖和物件鎖實踐

感謝［jiehao］同學的投稿，投稿可將文章傳送到[email protected] 類鎖和物件鎖是否會衝突？物件鎖和私有鎖是否會衝突？通過例項來進行說明。 一、相關約定 為了明確後文的描述，先對本文涉及到的鎖的相關定義作如下約定： 1. 類鎖：在程式碼中的方法上加了static和s

java中的類鎖和物件鎖對比分析

      說到鎖機制，不得不提到Thread執行緒，而又不得不提到synchronized關鍵字，這個單詞的意思是表示“同步”的意思。用它去修飾方法函式的時候，如果有多個執行緒同時呼叫這個方法函式的時候，那麼當一個執行緒獲得鎖的時候，其他的執行緒只

Java內部鎖（synchronized）中類鎖和物件鎖

版權宣告：本文為博主原創文章，轉載請註明出處。 https://blog.csdn.net/qq_25827845/article/details/77688880        synchronized是Java提供的內部鎖，裡邊有類鎖和物件鎖；在靜態方

【JVM第六篇】：Java-類鎖和物件鎖

1.類鎖和物件鎖的定義 物件鎖的定義 是針對一個物件的，它只在該物件的某個記憶體位置宣告一個標誌位標識該物件是否擁有鎖，所以它只會鎖住當前的物件。一般一個物件鎖是對一個非靜態成員變數進行syncronized修飾，或者對一個非靜態方法進行syncronized修飾。對於物件鎖，不

Java-類鎖和物件鎖

1.類鎖和物件鎖的定義 物件鎖的定義 是針對一個物件的，它只在該物件的某個記憶體位置宣告一個標誌位標識該物件是否擁有鎖，所以它只會鎖住當前的物件。一般一個物件鎖是對一個非靜態成員變數進行syncronized修飾，或者對一個非靜態方法進行syncronized修

Java的類鎖和物件鎖

類鎖和物件鎖不是同1個東西，一個是類的Class(對應的唯一的一個即這類的二進位制位元組碼)物件的鎖，1個是類的例項(！即new出的一個類的物件，一個類會有多個例項物件)的鎖。也就是說：1個執行緒訪

類鎖和物件鎖，synchronized修飾static方法與非static方法的區別

類鎖和物件鎖，synchronized修飾static方法與非static方法的區別  當synchronized修飾一個static方法時，多執行緒下，獲取的是類鎖(即Class本身，注意:不是例項

java synchronized的理解以及內建鎖和物件鎖

在java程式設計中，經常需要用到同步，而用得最多的也許是synchronized關鍵字了，下面看看這個關鍵字的用法。 因為synchronized關鍵字涉及到鎖的概念，所以先來了解一些相關的鎖知識。 java的內建鎖：每個java物件都可以用做一個實現

【面試題】sychronized中類鎖和物件鎖的區別

問：談一談sychronized中類鎖和物件鎖的區別。 答：類鎖和物件鎖是兩種不同的鎖，對靜態方法加鎖或者使用sychronized（XX.class）相當於加了類鎖，對例項方法加鎖或者採用sychronized（this或物件）相當於加了物件鎖，區別在於對於同一個類的不同

Synchronized的理解以及內建鎖和物件鎖

java的內建鎖：每個java物件都可以用做一個實現同步的鎖，這些鎖成為內建鎖。執行緒進入同步程式碼塊或方法的時候會自動獲得該鎖，在退出同步程式碼塊或方法時會釋放該鎖。獲得內建鎖的唯一途徑就是進入這個鎖的保護的同步程式碼塊或方法。 java內建鎖是一個互斥鎖，這就是意味著最

Java併發程式設計3 —— 物件鎖和類鎖

synchronized關鍵字作用在同步程式碼塊上，給共享變數“上鎖”可以解決執行緒安全問題。這把“鎖”可以作用在某個物件上，也可以作用在某個類上。 舉個栗子，有個自助銀行，裡面有兩臺ATM機，工作人員可以看到每次存取款之後機器裡鈔票的總金額數。現在有兩個人來存錢，各存50

Java的sychronized鎖中物件鎖和類鎖的區別

　　4. 同步加鎖的是物件，而不是程式碼。因此，如果你的類中有一個同步方法，這個方法可以被兩個不同的執行緒同時執行，只要每個執行緒自己建立一個的該類的例項即可。　　5. 不同的物件例項的synchronized方法是不相干擾的。也就是說，其它執行緒照樣可以同時訪問相同類的另一個物件例項中的synchroniz

java多執行緒物件鎖、類鎖、同步機制詳解

1.在java多執行緒程式設計中物件鎖、類鎖、同步機制synchronized詳解：     物件鎖：在java中每個物件都有一個唯一的鎖，物件鎖用於物件例項方法或者一個物件例項上面的。     類鎖：是用於一個類靜態方法或者class物件的，一個

Java synchronized併發同步詳細使用操作技巧-類鎖、物件鎖、this鎖、非this鎖

synchronized基礎特點：   synchronized鎖是可重入的，且在父子類繼承中同樣適用； synchronized鎖在遇到異常時自動釋放鎖； synchronized鎖的同步化不可以繼承；   1、非執行緒安全的高發區  

java多執行緒物件鎖 類鎖 同步機制詳解

分享一下我老師大神的人工智慧教程吧。零基礎，通俗易懂！風趣幽默！http://www.captainbed.net/ 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

java中的類鎖與物件鎖

在java中使用synchronized進行同步，鎖的型別有類鎖與物件鎖之分。 一、物件鎖  當多個執行緒操作同一個例項的時候才產生作用。  1、修飾程式碼塊    使用this:屬於物件鎖 public void do() { synchronized (

Android 技能圖譜學習路線系列-Java基礎之方法鎖、物件鎖、類鎖

先了解一下Synchronized的用法。 一、Synchronized的用法 在修飾程式碼塊的時候需要一個reference物件作為鎖的物件。 在修飾方法的時候預設是當前物件作為鎖的物件。 在修飾類時候預設是當前類的Class物件作為鎖的物件。 二、三種鎖得區

方法鎖、物件鎖和類鎖區別

synchronized用來處理多個執行緒同時訪問同一個類的一個程式碼塊、方法，甚至這個類。 （1）修飾程式碼塊時，需要設定一個參考物件作為鎖的物件(物件鎖)。 （2）修飾方法時，預設是當前對線作為鎖的物件。 （3）修飾類時，預設是當前類的Class物件作為鎖的物件。 1、物件鎖

【Java】 類鎖與物件鎖加鎖 synchronized 小解

  最近遇到多執行緒處理的問題，原來只使用過synchronized的方法鎖，對於其中的物件鎖和類鎖瞭解，但是沒仔細研究過。所以回去查了相關資料進行整理。 基礎知識   首先介紹一下物件鎖(也叫方法鎖)與類鎖有那些不同。下文中使用物件鎖稱呼代替方法鎖。   對於物件鎖，

方法鎖、物件鎖、類鎖的意義和區別

synchronized用來處理多個執行緒同時訪問同一個類的一個程式碼塊、方法，甚至這個類。 （1）修飾程式碼塊時，需要一個reference物件作為鎖的物件。 （2）修飾方法時，預設是當前對線作為鎖的