所有 ReadWriteLock 實現都必須保證 writeLock 操作的內存同步效果也要保持與相關 readLock 的聯系。也就是說，成功獲取讀鎖的線程會看到寫入鎖之前版本所做的所有更新。

與互斥鎖相比，讀-寫鎖允許對共享數據進行更高級別的并發訪問。雖然一次只有一個線程（writer 線程）可以修改共享數據，但在許多情況下，任何數量的線程可以同時讀取共享數據（reader 線程），讀-寫鎖利用了這一點。從理論上講，與互斥鎖相比，使用讀-寫鎖所允許的并發性增強將帶來更大的性能提高。在實踐中，只有在多處理器上并且只在訪問模式適用于共享數據時，才能完全實現并發性增強。

在 writer 釋放寫入鎖時，reader 和 writer 都處于等待狀態，在這時要確定是授予讀取鎖還是授予寫入鎖。Writer 優先比較普遍，因為預期寫入所需的時間較短并且不那么頻繁。Reader 優先不太普遍，因為如果 reader 正如預期的那樣頻繁和持久，那么它將導致對于寫入操作來說較長的時延。公平或者“按次序”實現也是有可能的。

在 reader 處于活動狀態而 writer 處于等待狀態時，確定是否向請求讀取鎖的 reader 授予讀取鎖。Reader 優先會無限期地延遲 writer，而 writer 優先會減少可能的并發。

我們創建信用卡類：

package com.entity; public class BankCard { private String cardid = 'XZ456789'; private int balance = 10000; public String getCardid() { return cardid; } public void setCardid(String cardid) { this.cardid = cardid; } public int getBalance() { return balance; } public void setBalance(int balance) { this.balance = balance; } }

里面有卡號和父母已經存的錢。

兒子花錢首先要獲得寫的鎖把卡鎖了，然后再花錢。之后放開這個鎖。

package com.thread; import java.util.concurrent.locks.ReadWriteLock; import com.entity.BankCard; /** * @說明 兒子類，只消費 */ public class Consumer implements Runnable { BankCard bc = null; ReadWriteLock lock = null; Consumer(BankCard bc, ReadWriteLock lock) { this.bc = bc; this.lock = lock; } public void run() { try { while(true){ lock.writeLock().lock(); System.out.print('兒子要消費，現在余額：' + bc.getBalance() + 't'); bc.setBalance(bc.getBalance() - 2000); System.out.println('兒子消費2000元，現在余額：' + bc.getBalance()); lock.writeLock().unlock(); Thread.sleep(3 * 1000);} } catch (Exception e) { e.printStackTrace(); } } }

父母類只監督這個卡的使用，獲得的是讀的鎖。

package com.thread;import java.util.concurrent.locks.ReadWriteLock;import com.entity.BankCard;/** * @說明 父母類，只監督 */public class Consumer2 implements Runnable {BankCard bc = null;int type = 0;ReadWriteLock lock = null;Consumer2(BankCard bc, ReadWriteLock lock,int type) {this.bc = bc;this.lock = lock;this.type = type;}public void run() {try {while(true){lock.readLock().lock(); if(type==2)System.out.println('父親要查詢，現在余額：' + bc.getBalance());elseSystem.out.println('老媽要查詢，現在余額：' + bc.getBalance());//lock.readLock().unlock();Thread.sleep(1 * 1000);}} catch (Exception e) {e.printStackTrace();}}}

運行程序，兒子開始花錢，父母兩人一直在查看花錢情況。

package com.thread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; import com.entity.BankCard; public class MainThread { public static void main(String[] args) { BankCard bc = new BankCard(); ReadWriteLock lock = new ReentrantReadWriteLock(); ExecutorService pool = Executors.newCachedThreadPool(); Consumer cm1 = new Consumer(bc, lock); Consumer2 cm2 = new Consumer2(bc, lock , 1); Consumer2 cm3 = new Consumer2(bc, lock , 2); pool.execute(cm1); pool.execute(cm2); pool.execute(cm3); } }

我們來看一下運行結果：

兒子要消費，現在余額：10000 兒子消費2000元，現在余額：8000 老媽要查詢，現在余額：8000 父親要查詢，現在余額：8000 父親要查詢，現在余額：8000 老媽要查詢，現在余額：8000 老媽要查詢，現在余額：8000 父親要查詢，現在余額：8000 兒子要消費，現在余額：8000 兒子消費2000元，現在余額：6000 父親要查詢，現在余額：6000 老媽要查詢，現在余額：6000 老媽要查詢，現在余額：6000 父親要查詢，現在余額：6000 父親要查詢，現在余額：6000 老媽要查詢，現在余額：6000 老媽要查詢，現在余額：6000 兒子要消費，現在余額：6000 兒子消費2000元，現在余額：4000 父親要查詢，現在余額：4000

讀寫鎖是互斥的，但是對于讀來說沒有互斥性。

也就是說讀和寫必須分開，但是資源可以同時被幾個線程訪問。不管是讀還是寫沒有釋放鎖，其他線程就一直等待鎖的釋放。

我們來注釋父母監督時鎖的釋放：

lock.readLock().unlock();

兒子要消費，現在余額：10000 兒子消費2000元，現在余額：8000 父親要查詢，現在余額：8000 老媽要查詢，現在余額：8000 老媽要查詢，現在余額：8000 父親要查詢，現在余額：8000 老媽要查詢，現在余額：8000 父親要查詢，現在余額：8000 老媽要查詢，現在余額：8000 父親要查詢，現在余額：8000

可以看到兒子花了一次錢后，父母把卡給鎖了，兒子不能在花錢，但是父母兩個人都可以一直查詢卡的余額。

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持好吧啦網。