2. 程式人生 > >Java執行緒總結（八）：併發包------讀寫鎖ReadWriteLock的簡單例子詳細理解

Java執行緒總結（八）：併發包------讀寫鎖ReadWriteLock的簡單例子詳細理解

阿新 • • 發佈：2019-01-29

初次接觸ReadWriteLock類時也在網上查了很多資料，很容易瞭解到ReadWriteLock是讀寫鎖，並且讀寫鎖的機制有以下三個特點：

  讀鎖---讀鎖    （不互斥）

  讀鎖---寫鎖     （互斥）

  寫鎖---寫鎖     （互斥）

什麼意思呢？

網上很多資料，直接用這三個特點實現一個快取的例子進行了講解，但是對小白來說還有那麼一絲絲的迷惑（老鳥忽略），下面就逐一演示：

1. 讀鎖---讀鎖

main方法裡兩個執行緒都在讀資料，在read()方法裡已經上了讀鎖且沒有解鎖（為了測試）

public class ReadWriteLockTest {
	public static void main(String[] args) {
		final ReadAndWrite raw = new ReadAndWrite();
		raw.map.put("data", 1);
		//執行緒1，讀資料
		new Thread(
				new Runnable() {
					@Override
					public void run() {
						while(true)
							raw.read();						
					}
		}).start();
		//執行緒2，讀資料
		new Thread(
				new Runnable() {
					@Override
					public void run() {
						while(true)
							raw.read();
					}
		}).start();
		
	}
}


class ReadAndWrite{
	ReadWriteLock rwlock = new ReentrantReadWriteLock();//讀寫鎖
	Map map = new HashMap();//共享的資料
	public void read(){
		rwlock.readLock().lock();//上讀鎖，且沒有解鎖
		System.out.println(Thread.currentThread().getName()+"讀開始...");
		System.out.println(Thread.currentThread().getName()+"讀資料為："+map.get("data"));
		System.out.println(Thread.currentThread().getName()+"讀結束...");
		try {
			Thread.sleep((long) (Math.random()*1000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

（可以看到兩個執行緒都能不斷讀資料，記住這個現象，接著看下面的例子進行對比）

執行結果：

Thread-0讀開始...
Thread-0讀資料為：1
Thread-0讀結束...
Thread-1讀開始...
Thread-1讀資料為：1
Thread-1讀結束...
Thread-1讀開始...
Thread-1讀資料為：1
Thread-1讀結束...
Thread-0讀開始...
Thread-0讀資料為：1
Thread-0讀結束...

2. 讀鎖---寫鎖 

main方法裡執行緒1在讀資料，執行緒2在寫資料，將read()方法裡的“解讀鎖”註釋掉和不註釋分別執行對比結果

public class ReadWriteLockTest2 {
	public static void main(String[] args) {
		final ReadAndWrite raw = new ReadAndWrite();
		raw.map.put("data", 1);
		//執行緒1，讀資料
		new Thread(
				new Runnable() {
					@Override
					public void run() {
						while(true)
							raw.read();						
					}
		}).start();
		//執行緒2，寫資料
		new Thread(
				new Runnable() {
					@Override
					public void run() {
						while(true)
							raw.write();
					}
		}).start();
		
	}
}

class ReadAndWrite{
	ReadWriteLock rwlock = new ReentrantReadWriteLock();//讀寫鎖
	Map map = new HashMap();//共享的資料
	public void read(){
		rwlock.readLock().lock();//上讀鎖
		System.out.println(Thread.currentThread().getName()+"讀開始...");
		System.out.println(Thread.currentThread().getName()+"讀資料為："+map.get("data"));
		System.out.println(Thread.currentThread().getName()+"讀結束...");
		<span style="color:#ff0000;">//rwlock.readLock().unlock();//解讀鎖</span>
		try {
			Thread.sleep((long) (Math.random()*1000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	public void write(){
		rwlock.writeLock().lock();//上寫鎖
		System.out.println(Thread.currentThread().getName()+"寫開始...");
		double data = Math.random();
		map.put("data", data);
		System.out.println(Thread.currentThread().getName()+"寫資料為："+data);
		System.out.println(Thread.currentThread().getName()+"寫結束...");
		rwlock.writeLock().unlock();//解寫鎖
		try {
			Thread.sleep((long) (Math.random()*1000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

read()方法裡“解讀鎖”註釋掉，（可以看到只有執行緒1在讀資料，執行緒2是阻塞狀態無法寫資料，證明了讀鎖和寫鎖的互斥）

執行結果：

Thread-0讀開始...
Thread-0讀資料為：1
Thread-0讀結束...
Thread-0讀開始...
Thread-0讀資料為：1
Thread-0讀結束...

read()方法裡“解讀鎖”不註釋，（可以看到執行緒1和執行緒2交替的讀和寫資料，也就是讀鎖解了，其他執行緒就可以寫資料了，寫鎖解了，其他執行緒就可以讀資料了）

執行結果：

Thread-0讀開始...
Thread-0讀資料為：1
Thread-0讀結束...
Thread-1寫開始...
Thread-1寫資料為：0.4387383401358649
Thread-1寫結束...

3. 寫鎖---寫鎖

相信看了上面兩個例子，基本就明白了寫鎖和寫鎖是怎麼互斥的，同樣執行緒1和執行緒2都進行寫資料，write()方法上寫鎖並且不解鎖（測試才這樣寫的）

public class ReadWriteLockTest3 {
	public static void main(String[] args) {
		final ReadAndWrite raw = new ReadAndWrite();
		raw.map.put("data", 1);
		//執行緒1，寫資料
		new Thread(
				new Runnable() {
					@Override
					public void run() {
						while(true)
							raw.write();						
					}
		}).start();
		//執行緒2，寫資料
		new Thread(
				new Runnable() {
					@Override
					public void run() {
						while(true)
							raw.write();
					}
		}).start();
		
	}
}

class ReadAndWrite{
	ReadWriteLock rwlock = new ReentrantReadWriteLock();//讀寫鎖
	Map map = new HashMap();//共享的資料
	public void write(){
		rwlock.writeLock().lock();//上寫鎖
		System.out.println(Thread.currentThread().getName()+"寫開始...");
		double data = Math.random();
		map.put("data", data);
		System.out.println(Thread.currentThread().getName()+"寫資料為："+data);
		System.out.println(Thread.currentThread().getName()+"寫結束...");
		try {
			Thread.sleep((long) (Math.random()*1000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
（write()方法裡上了寫鎖並且沒有解鎖，所以只有一個執行緒在寫資料，其他執行緒無法進行寫資料，你也可以把解鎖給加上，執行一下對比看看）
執行結果：

Thread-0寫開始...
Thread-0寫資料為：0.2439106501627466
Thread-0寫結束...
Thread-0寫開始...
Thread-0寫資料為：0.44688857423885386
Thread-0寫結束...
Thread-0寫開始...

相信通過以上的程式碼和執行結果進行對比和觀察，應該已經理解了ReadWriteLock三個特點，下面貼上實現快取類的程式碼（jdk中ReentrantReadWriteLock類的一個例子）：

public class Cache {
	private Map<String, Object> cache = new HashMap<String, Object>();
	private ReadWriteLock rwLock = new ReentrantReadWriteLock();

	public Object getData(String key) {
		// 首先上讀鎖
		rwLock.readLock().lock();
		// 首先從快取中獲取
		Object value = null;
		try {
			Thread.sleep(1000);
			value = cache.get(key);
			if (value == null) {
				// 如果快取中沒有資料,那麼就從資料庫中獲取
				// 但此時需要上寫鎖，只需要讓一個程序進行寫資料
				// 首先去除讀鎖，然後加上寫鎖
				rwLock.readLock().unlock();
				rwLock.writeLock().lock();
				try {
					// 注意防止多執行緒執行到上一步，某個執行緒寫完資料後
					// 別的執行緒就需要看是否有資料再決定是否進行寫操作
					// 在寫之前再讀一次,防止最開始的執行緒都進行寫操作</span>
					value = cache.get(key);
					// 第一個執行緒寫完後，防止後面的執行緒再次寫資料
					if (value == null) {
						System.out.println("有執行緒寫資料........");
						value = "資料庫中獲取";
						// 將資料放入快取
						cache.put(key, value);
						System.out.println("資料寫完了.......");
					}
				} finally {
					rwLock.readLock().lock();// 恢復讀鎖，鎖的重入
					rwLock.writeLock().unlock();
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			rwLock.readLock().unlock();// 解讀鎖
		}
		return value;
	}
}




相關推薦

Java執行緒總結（八）：併發包------讀寫鎖ReadWriteLock的簡單例子詳細理解

初次接觸ReadWriteLock類時也在網上查了很多資料，很容易瞭解到ReadWriteLock是讀寫鎖，並且讀寫鎖的機制有以下三個特點：  讀鎖---讀鎖    （不互斥）  讀鎖---寫鎖     （互斥）  寫鎖---寫鎖     （互斥）什麼意思呢？網上很多資料，

java基礎學習總結（八）：Java中的反射

Native      JDK開放給使用者的原始碼中隨處可見Native方法，被Native關鍵字宣告的方法說明該方法不是以Java語言實現的，而是以本地語言實現的，Java可以直接拿來用。這裡有一個概念，就是本地語言，本地語言這四個字，個人理解應該就是可以和作業系

JAVA執行緒總結（ 二）

繼續上篇的總結，這次我們講執行緒同步機制 執行緒同步是為了確保執行緒安全，所謂執行緒安全指的是多個執行緒對同一資源進行訪問時，有可能產生資料不一致問題，導致執行緒訪問的資源並不是安全的。如果多執行緒程式執行結果和單執行緒執行的結果是一樣的，且相關變數的值與預期值一樣，則是執行緒安全的。

Java多執行緒學習（十）：AQS 原理以及 AQS 同步元件總結

常見問題：AQS 原理？;CountDownLatch和CyclicBarrier瞭解嗎,兩者的區別是什麼？用過Semaphore嗎？ 本節思維導圖： 阿里雲產品 1888 代金券領取:https://promotion.aliyun.com/ntms

java多執行緒系列（一）：Thread、Runnable、Callable實現多執行緒的區別

實現多執行緒 java實現多執行緒的方法有三種，分別是繼承thread類，實現runnable介面，實現callable介面（call方法有返回值） /** * 繼承Thread */ public class MyThread extends Thread{ int a = 0;

多執行緒學習（4）：三種實現Java多執行緒的方法：Thread、Callable和Runable 的比較與區別

2018年10月03日 目錄 前言 前言 JVM允許應用程式併發執行多執行緒：最常用的是兩個方法：（1）基礎Thread類，重寫run（）方法；（2）或實現Runnable 介面，實現介面的run（）方法；（3）另外一種方法是：實現callable 介面

JAVA執行緒總結（完結篇）

執行緒池概述 程式啟動一個新執行緒成本是比校高的,因カ它渉及到要與作業系統迸行互動而使用執行緒池可以很好的提高效能,尤其是當程式中要建立大量生存期很短的執行緒吋,更應該考慮執行緒池.執行緒池裡的毎一個執行緒程式碼結束後,井不會死亡,而是再次回到執行緒池中成為空閒

JAVA多執行緒入門（二）：JAVA中如何寫多執行緒

第一種方式：繼承Thread 步驟： 1.建立執行緒類，繼承自Thread + 重寫run，run中寫執行緒體，執行緒體就是mian()函式裡面的寫法 2.使用執行緒： 2.1 建立執行緒物件 2.2 執行緒物件.start() 步驟展示： 1. public

Java多執行緒總結（6）— 執行緒池的基本使用和執行流程分析

1 執行緒池的實現原理及基本類結構   合理利用執行緒池能夠帶來三個好處。 降低資源消耗。通過重複利用已建立的執行緒降低執行緒建立和銷燬造成的消耗。 提高響應速度。當任務到達時，任務可以不需要等到執行緒建立就能立即執行。 提高執行緒的可管理性。執行緒是稀缺

Java 多執行緒基礎（八）執行緒讓步

 Java 多執行緒基礎（八）執行緒讓步 yield 一、yield 介紹 yield()的作用是讓步。它能讓當前執行緒由“執行狀態”進入到“就緒狀態”，從而讓其它具有相同優先順序的等待執行緒獲取執行權；但是，並不能保證在當前執行緒呼叫yield()之後，其它具有相同優先順序的執行緒就一定

java基礎學習總結（十三）：Java異常處理

一、JAVA異常       異常是指不期而至的各種情況，如：檔案找不到、網路連線失敗、非法引數等。異常是一個事件，它發生在程式執行期間，干擾了正常的指令流程。Java通過API中的Throwable類的眾多子類描述各種不同的異常。因而，Java異常都是物件，是Th

java基礎學習總結（十）：可變長度引數以及foreach迴圈原理

一、語法糖        語法糖是一種幾乎每種語言或多或少都提供過的一些方便程式設計師開發程式碼的語法，它只是編譯器實現的一些小把戲罷了，編譯期間以特定的位元組碼或者特定的方式對這些語法做一些處理，開發者就可以直接方便地使用了。這些語法糖雖然不會提供實質性

java基礎學習總結（九）：深入理解Java泛型

一、什麼是泛型         “泛型” 意味著編寫的程式碼可以被不同型別的物件所重用。泛型的提出是為了編寫重用性更好的程式碼。泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。 比如常見的集合類 LinkedList: publi

java基礎學習總結（七）：Cloneable介面和Object的clone()方法

為什麼要克隆 為什麼要使用克隆，這其實反映的是一個很現實的問題，假如我們有一個物件： public class SimpleObject implements Cloneable { private String str; public SimpleObject()

JVM除錯常用命令——jstack命令與Java執行緒棧（1）

1 jstack 命令 jstack命令的主要作用是列印指定Java程序中每一個執行緒的工作狀態，以及每個執行緒棧當前的方法執行順序等詳細情況。為什麼jstack命令不和jmap、jinfo、jstat等命令一同講解，而要單獨成文呢？因為通過jstack命令給出的執行緒棧詳細情況，可

JVM除錯常用命令——jstack命令與Java執行緒棧（2）

（接上文《JVM除錯常用命令——jstack命令與Java執行緒棧（1）》） 1.2、jstack中的執行緒關鍵資訊 上一篇文章中我們介紹了jstack命令的基本使用，也列舉了一個比較簡單的示例。雖然之前的文章內容中沒有介紹查詢結果中的一些關鍵資訊，但是這並不影響什麼。本片文章中

java執行緒池（newCachedThreadPool）的使用

import java.util.concurrent.*; /** * java執行緒池的使用 * 這個【可快取執行緒池】，沒看出來有什麼用呢。。。 */ public class Exe

執行緒學習（三）：執行緒的互斥

生產者與消費者模型 在講同步和互斥之前，首先了解一下消費者模型 什麼是消費者模型？ 消費者模型是一個描述消費者和生產者之間的關係的一個模型，生產者和消費者模型指的是在一個場所中，兩個角色，三種關係 消費者和消費者之間——互斥 消費者之間是競爭關係，比如有一個

多執行緒學習（5）：synchronized 的基礎使用

2018年10月03日 目錄 前言 前言 java中已經有了內建鎖：synchronized，synchronized的特點是使用簡單，一切交給JVM去處理，不需要顯示釋放； j

Java中設計模式（八）：建造者模式

介紹 今天我們將研究java中的Builder模式。Builder 設計模式是一種創造性的設計模式，如工廠模式和抽象工廠模式。 當Object包含許多屬性時，引入了Builder模式來解決Factory和Abstract Factory設計模式的一些問題。 當Object包含許多屬性時，Factory和Abs