所有 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());
				else
					System.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,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

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

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。