2. 程式人生 > >JAVA多執行緒 重入鎖和讀寫鎖

JAVA多執行緒 重入鎖和讀寫鎖

阿新 • • 發佈：2018-11-20

在java多執行緒中，我們真的可以使用synchronized關鍵字來實現執行緒間的同步互斥工作，那麼其實還有一個更優秀的機制去完成這個“同步互斥”工作，他就是Lock物件，重入鎖和讀寫鎖。他們具有比synchronized更為強大的功能，並且有嗅探鎖定、多路分支等功能。

一、重入鎖

在需要進行同步的程式碼部分加上鎖定，但不要忘記最後一定要釋放鎖定，不然會造成鎖永遠無法釋放，其他執行緒永遠進不來的結果。
ReentrantLock (重入鎖)示例：

/**
 * 重入鎖
 * @author yanghz
 * @createDate 2018年11月19日
 */
public
 
 class UseReentrantLock {
	
	private Lock lock=new ReentrantLock();
	
	public void method1(){
		try{
			lock.lock();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入method1");
			Thread.sleep(1000);
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"退出method1");
			Thread.
 
sleep(1000);
		}catch(Exception e){			
		}finally{
			//釋放鎖
			lock.unlock();
		}		
	}
	public void method2(){
		try{
			lock.lock();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入method2");
			Thread.sleep(2000);
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"退出method2"
 
);
			Thread.sleep(1000);
		}catch(Exception e){			
		}finally{
			//釋放鎖
			lock.unlock();
		}		
	}
	public static void main(String[] args) {
		final UseReentrantLock ur=new UseReentrantLock();
		Thread t1=new Thread(new Runnable() {
			
			@Override
			public void run() {
				ur.method1();
				ur.method2();
			}
		},"t1");
		t1.start();
	}	
}

執行結果：
當前執行緒：t1進入method1
當前執行緒：t1退出method1
當前執行緒：t1進入method2
當前執行緒：t1退出method2

Condition類的使用：


/**
 * Lock的通知和等待用法
 * @author yanghz
 * @createDate 2018年11月19日
 */
public class UseCondition {
	
	private Lock lock=new ReentrantLock();
	private Condition condition=lock.newCondition();
	
	public void method1(){		
		try {
			lock.lock();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入等待狀態。。。。");
			Thread.sleep(3000);
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"釋放鎖。。。。");
			condition.await();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"繼續執行。。。。");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public void method2(){		
		try {
			lock.lock();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入等待狀態。。。。");
			Thread.sleep(3000);
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"發起喚醒鎖。。。。");
			condition.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		final UseCondition uc=new UseCondition();
		Thread t1=new Thread(new Runnable() {
			public void run() {
				uc.method1();
			}
		},"t1");
		
		Thread t2=new Thread(new Runnable() {
			public void run() {
				uc.method2();
			}
		},"t2");
		
		t1.start();
		t2.start();
	}

}

輸出結果：

當前執行緒：t1進入等待狀態。。。。
當前執行緒：t1釋放鎖。。。。
當前執行緒：t2進入等待狀態。。。。
當前執行緒：t2發起喚醒鎖。。。。
當前執行緒：t1繼續執行。。。。

多Condition

/**
 * 多Condition
 * @author yanghz
 * @createDate 2018年11月19日
 */
public class UseManyCondition {

	private Lock lock = new ReentrantLock();
	private Condition c1=lock.newCondition();
	private Condition c2=lock.newCondition();
	
	public void m1(){
		try{
			lock.lock();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入方法m1等待...");
			c1.await();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"方法m1繼續執行...");
		}catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void m2(){
		try{
			lock.lock();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入方法m2等待...");
			c1.await();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"方法m2繼續執行...");
		}catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void m3(){
		try{
			lock.lock();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入方法m3等待...");
			c2.await();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"方法m3繼續執行...");
		}catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void m4(){
		try{
			lock.lock();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"喚醒...");
			c1.signalAll();
		}finally{
			lock.unlock();
		}
	}
	public void m5(){
		try{
			lock.lock();
			System.out.println("當前執行緒："+Thread.currentThread().getName()+"喚醒...");
			c2.signal();
		}finally{
			lock.unlock();
		}
	}
	public static void main(String[] args) {
		final UseManyCondition umc=new UseManyCondition();
		Thread t1=new Thread(new Runnable() {			
			@Override
			public void run() {
				umc.m1();
			}
		},"t1");
		Thread t2=new Thread(new Runnable() {			
			@Override
			public void run() {
				umc.m2();
			}
		},"t2");
		Thread t3=new Thread(new Runnable() {			
			@Override
			public void run() {
				umc.m3();
			}
		},"t3");
		Thread t4=new Thread(new Runnable() {			
			@Override
			public void run() {
				umc.m4();
			}
		},"t4");
		Thread t5=new Thread(new Runnable() {			
			@Override
			public void run() {
				umc.m5();
			}
		},"t5");
		t1.start();
		t2.start();
		t3.start();
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t4.start();
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t5.start();
	}
}

輸出結果：

當前執行緒：t2進入方法m2等待…
當前執行緒：t1進入方法m1等待…
當前執行緒：t3進入方法m3等待…
當前執行緒：t4喚醒…
當前執行緒：t2方法m2繼續執行…
當前執行緒：t1方法m1繼續執行…
當前執行緒：t5喚醒…
當前執行緒：t3方法m3繼續執行…

總結：當m1，m2，m3同時等待的時候，m4喚醒的只有m1,m2。m5喚醒m3
await()相當於synchronized裡面使用的wait();
signal()相當於synchronized裡面使用的notify();

Lock/Condition其他方法和用法：

公平鎖和非公平鎖：公平鎖浪費資源，非公平鎖不需要維護是否公平所以效能高於公平鎖。
Lock lock=new ReentrantLock(boolean isFair);
Lock用法：
tryLock():嘗試獲得鎖，獲得結果用true/false返回。true表示獲得，false表示鎖被佔用。
tryLock():在給定的世界內嘗試獲得鎖，獲得結果用true/false返回
isFair():是否是公平鎖。
isLocked():是否鎖定。
getHoldCount():查詢當前執行緒保持此鎖的個數，也就是呼叫lock()次數。
lockInterruptibly():有限響應中斷的鎖。
getQueueLength():返回正在等待獲取此鎖的執行緒數。
getWaitQueueLength():返回等待與鎖定相關的給定條件Condition的執行緒數。
hasQueuedThread(Thread thread):查詢指定的執行緒是否正在等待此鎖。
hasQueuedThreads():查詢是否有執行緒正在等待此鎖。
hasWaiters():查詢是否有執行緒正在等待與此鎖定有關的Condition條件。

二、ReentrantReadWriteLock讀寫鎖

讀寫鎖ReentrantReadWriteLock，其核心就是實現讀寫分離的鎖，在高併發訪問下，尤其是讀多寫少的情況下，效能要遠高於重入鎖。
synchronized、ReentrantLock，同一時間內，只能有一個執行緒進行訪問被鎖定的程式碼，那麼讀寫鎖則不同，其本質是分成兩個鎖，即讀鎖、寫鎖。在讀鎖下，多個執行緒可以併發的進行訪問，但是在寫鎖的時候，只能一個一個的順序訪問。
口訣：讀讀共享，寫寫互斥，讀寫互斥。
示例：

/**
 * 讀寫鎖
 * @author yanghz
 * @createDate 2018年11月19日
 */
public class UseReentrantReadWriteLock {

	private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
	private ReadLock readLock = readWriteLock.readLock();
	private WriteLock writeLock = readWriteLock.writeLock();

	public void read() {
		try {
			readLock.lock();
			System.out.println("當前執行緒：" + Thread.currentThread().getName() + "進入。。。");
			Thread.sleep(3000);
			System.out.println("當前執行緒：" + Thread.currentThread().getName() + "退出。。。");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			readLock.unlock();
		}
	}

	public void write() {
		try {
			writeLock.lock();
			System.out.println("當前執行緒：" + Thread.currentThread().getName() + "進入。。。");
			Thread.sleep(3000);
			System.out.println("當前執行緒：" + Thread.currentThread().getName() + "退出。。。");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			writeLock.unlock();
		}
	}

	public static void main(String[] args) {
		final UseReentrantReadWriteLock urr = new UseReentrantReadWriteLock();
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				urr.read();
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				urr.read();
			}
		}, "t2");
		Thread t3 = new Thread(new Runnable() {

			@Override
			public void run() {
				urr.write();
			}
		}, "t3");

		Thread t4 = new Thread(new Runnable() {

			@Override
			public void run() {
				urr.write();
			}
		}, "t4");
		
//		t1.start();//R
//		t2.start();//R
		t3.start();//w
		t4.start();//w
		//RR
//		當前執行緒：t1進入。。。
//		當前執行緒：t2進入。。。
//		當前執行緒：t1退出。。。
//		當前執行緒：t2退出。。。
		//RW
//		當前執行緒：t3進入。。。
//		當前執行緒：t3退出。。。
//		當前執行緒：t2進入。。。
//		當前執行緒：t2退出。。。
		//WW
//		當前執行緒：t4進入。。。
//		當前執行緒：t4退出。。。
//		當前執行緒：t3進入。。。
//		當前執行緒：t3退出。。。
	}
}

總結：分別對應RR、RW、WW執行輸出的結果可以對應上口訣

相關推薦

Java多執行緒程式設計-（15）-讀寫鎖ReentrantReadWriteLock深入分析

上兩篇： 一、前言 上兩篇的內容中已經介紹到了鎖的實現主要有ReentrantLock和ReentrantReadWriteLock。 ReentrantLock是重入鎖，顧名思義就是支援重進入的鎖，他表示該鎖能夠支援一個執行緒對資源的重複加鎖

JAVA多執行緒 重入鎖和讀寫鎖

在java多執行緒中，我們真的可以使用synchronized關鍵字來實現執行緒間的同步互斥工作，那麼其實還有一個更優秀的機制去完成這個“同步互斥”工作，他就是Lock物件，重入鎖和讀寫鎖。他們具有比synchronized更為強大的功能，並且有嗅探鎖定、多路分支等功能。 一、重入鎖

Java多執行緒--重入鎖的實現原理

protectedfinalboolean tryRelease(int releases) {               int c = getState() - releases;               if (Thread.currentThread() != getExclusiveO

JAVA基礎24-多執行緒（四）【讀寫鎖，阻塞佇列，執行緒池】

一、讀寫鎖   使用步驟 二、阻塞佇列 (BlockingQueue) 提供執行緒安全的佇列訪問方式； 當阻塞佇列進行插入資料時，若佇列滿，則執行緒阻塞，直到佇列非滿的時候 當阻塞佇列取資料時，若佇列為空，則執行緒阻塞直到佇列非空時候。

Java多執行緒之Executor框架和手寫簡易的執行緒池

目錄 Java多執行緒之一執行緒及其基本使用 Java多執行緒之二(Synchronized) Java多執行緒之三volatile與等待通知機制示例 執行緒池 什麼是執行緒池 執行緒池一種執行緒使用模式，執行緒池會維護多個執行緒，等待著分配可併發執行的任務，當有任務需要執行緒執行時

多執行緒學習筆記五之讀寫鎖實現分析

目錄 簡介 讀寫狀態 讀鎖計數器 共享鎖的獲取 tryAcquireShared(int unused) doAcquireShared(int arg) 共享鎖的釋放 tryReleaseShared(int unus

java多執行緒批量讀取檔案(二)--讀寫分離

package com.net.thread.future; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInp

Java 多執行緒學習筆記（五）synchronized 鎖重入

關鍵字synchronized 擁有鎖重入的功能，也就是使用synchronized時，當一個執行緒得到一個物件鎖後，再次請求此物件鎖時是可以再次得到該物件的鎖的。這也就證明在一個synchroniz

Java多執行緒中Synchronized簡介和Static Synchronized的區別

在進行Java開發時，多執行緒的開發是經常會使用的。首先會問一個小問題啊，在Java中有幾種方法可以建立一個執行緒？ 我給的答案是3種。（如果還有其他的請留言告訴我哈。） 1、建立直接繼承自Thread類建立執行緒子類。   步驟如下：a 定義一個子類，同時

Java多執行緒-併發之sleep() 和 wait(n) 、 wait() 的區別

sleep() 和 wait(n) 、 wait() 的區別 答： sleep 方法：是 Thread 類的靜態方法，當前執行緒將睡眠 n 毫秒，執行緒進入阻塞狀態。當睡眠時間到了，會接觸阻塞，進入可執行狀態，等待 CPU 的到來。睡眠不釋放鎖（如果有的話） wai

java多執行緒：1程序和執行緒

多執行緒樣例 我們用工人卸貨舉例：有一集裝箱的貨物等待卸車，共100個箱子，一個工人一次只能搬一個箱子。 如果只有一個工人，那麼該工人需要搬運100次，而且是不停歇的搬運。 如果有5個或者10個工人，那麼平均每個工人只需要搬運20或者10次就可以了。 甚至有1

Java 多執行緒高併發 3.3 — Semaphore 共享鎖使用

Semaphore 是共享鎖的一種，字面上意思就是訊號量鎖 顧名思義，一個可以共享的鎖，可以讓多個執行緒共享同一把鎖，例如同一條馬路可以讓 4 臺車同時並行跑，相當於可以讓 4 個執行緒共享一把鎖，臨

java多執行緒3：關鍵字synchronized取得的鎖都是物件鎖，而不是把一段程式碼或者方法（函式）當作鎖

java多執行緒3：關鍵字synchronized取得的鎖都是物件鎖，而不是把一段程式碼或者方法（函式）當作鎖 a.當多個執行緒訪問同一個物件的時候，哪個執行緒先執行帶synchronized關鍵字的方法，哪個執行緒就該方法所屬物件的鎖Lock，那麼其他物件就智慧呈等待狀態。但是如果多個執行緒訪

Java多執行緒之 Lock介面和ReentrantLock的使用

                在多執行緒開發中，除了synchronized這個關鍵字外，我們還能通過Lock介面來實現這種效果。通過Lock介面來實現這種多執行緒加鎖效果的好處是非常的靈活，我們不在需要對整個函式加鎖，而且可以很方便的把他放在我們函式的任何一個地方，非常的稱心，而且從效率上來說，使用Loc

Java多執行緒之—Synchronized方式和CAS方式實現執行緒安全效能對比

效能比較猜想 1.大膽假設 在設計試驗方法之前，針對Synchronized和CAS兩種方式的特點，我們先來思考一下兩種方式效率如何？ 首先，我們在回顧一下兩種方式是如何保證執行緒安全的。Synchronized方式通過大家應該很熟悉，他的行為非常悲觀，只要有一個執行緒進

Java多執行緒之建立任務和執行緒

Runnable建立執行緒 任務就是物件。為了建立任務，必須首先為任務定義一個類。任務類必須實現Runnable介面。Runnable介面非常簡單，它只包含一個run方法。需要實現這個方法來告訴系統執行緒將如何執行。開發一個任務類的模板如圖29-2a所示。

java多執行緒交替列印數字和字母

題目： 1.開啟兩個執行緒，一個執行緒列印A～Z，另一個執行緒列印1～52的資料。 2.實現交替列印，輸出結果為12A34B………..5152Z. 3.請用多執行緒方式實現。 使用阻塞佇列實現

java 多執行緒之future用法和意義

在併發程式設計時，一般使用runnable，然後扔給執行緒池完事，這種情況下不需要執行緒的結果。所以run的返回值是void型別。 如果是一個多執行緒協作程式，比如菲波拉切數列，1，1，2，3，5，8...使用多執行緒來計算。但後者需要前者的結果，就需要用callable介

Java多執行緒中的final和static

看Android的多執行緒發現其實是Java的多執行緒。我找了一本Java程式設計思想學習Java的併發機制。寫了一個demo，遇到一些問題，雖然最後想明白了，但是也暴露了我的Java基礎差勁的事實。之後我會通過寫部落格的方式來提高Java水平。現在說一下我的問

Java多執行緒之 使用wait和notify實現生產者消費者模型

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