Lock比傳統線程模型中的synchronized方式更加面向對象,與生活中的鎖類似,鎖本身也應該是一個對象。兩個線程執行的代碼片段要實現同步互斥的效果,它們必須用同一個Lock對象。
讀寫鎖:分爲讀鎖和寫鎖,多個讀鎖不互斥,讀鎖與寫鎖互斥,這是由jvm自己控制的,你只要上好相應的鎖即可。如果你的代碼只讀數據,可以很多人同時讀,但不能同時寫,那就上讀鎖;如果你的代碼修改數據,只能有一個人在寫,且不能同時讀取,那就上寫鎖。總之,讀的時候上讀鎖,寫的時候上寫鎖!
ReentrantReadWriteLock會使用兩把鎖來解決問題,一個讀鎖,一個寫鎖
線程進入讀鎖的前提條件:
沒有其他線程的寫鎖,
沒有寫請求或者有寫請求,但調用線程和持有鎖的線程是同一個
線程進入寫鎖的前提條件:
沒有其他線程的讀鎖
沒有其他線程的寫鎖
到ReentrantReadWriteLock,首先要做的是與ReentrantLock劃清界限。它和後者都是單獨的實現,彼此之間沒有繼承或實現的關係。然後就是總結這個鎖機制的特性了:
(a).重入方面其內部的WriteLock可以獲取ReadLock,但是反過來ReadLock想要獲得WriteLock則永遠都不要想。
(b).WriteLock可以降級爲ReadLock,順序是:先獲得WriteLock再獲得ReadLock,然後釋放WriteLock,這時候線程將保持Readlock的持有。反過來ReadLock想要升級爲WriteLock則不可能,爲什麼?參看(a),呵呵.
(c).ReadLock可以被多個線程持有並且在作用時排斥任何的WriteLock,而WriteLock則是完全的互斥。這一特性最爲重要,因爲對於高讀取頻率而相對較低寫入的數據結構,使用此類鎖同步機制則可以提高併發量。
(d).不管是ReadLock還是WriteLock都支持Interrupt,語義與ReentrantLock一致。
(e).WriteLock支持Condition並且與ReentrantLock語義一致,而ReadLock則不能使用Condition,否則拋出UnsupportedOperationException異常。
下面看一個讀寫鎖的例子:
package com.thread;
import java.util.Random;
importjava.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockTest {
public static void main(String[] args) {
final Queue3 q3 = new Queue3();
for(int i=0;i<3;i++)
{
new Thread(){
public void run(){
while(true){
q3.get();
}
}
}.start();
}
for(int i=0;i<3;i++)
{
new Thread(){
public void run(){
while(true){
q3.put(newRandom().nextInt(10000));
}
}
}.start();
}
}
}
class Queue3{
private Object data = null;//共享數據,只能有一個線程能寫該數據,但可以有多個線程同時讀該數據。
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
public void get(){
rwl.readLock().lock();//上讀鎖,其他線程只能讀不能寫
System.out.println(Thread.currentThread().getName() + " be ready toread data!");
try {
Thread.sleep((long)(Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "have readdata :" + data);
rwl.readLock().unlock(); //釋放讀鎖,最好放在finnaly裏面
}
public void put(Object data){
rwl.writeLock().lock();//上寫鎖,不允許其他線程讀也不允許寫
System.out.println(Thread.currentThread().getName() + " be ready towrite data!");
try {
Thread.sleep((long)(Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data = data;
System.out.println(Thread.currentThread().getName() + " have writedata: " + data);
rwl.writeLock().unlock();//釋放寫鎖
}
}
下面使用讀寫鎖模擬一個緩存器:
package com.thread;
import java.util.HashMap;
import java.util.Map;
importjava.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class CacheDemo {
private Map<String, Object> map = new HashMap<String,Object>();//緩存器
private ReadWriteLock rwl = new ReentrantReadWriteLock();
public static void main(String[] args) {
}
public Object get(String id){
Object value = null;
rwl.readLock().lock();//首先開啓讀鎖,從緩存中去取
try{
value = map.get(id);
if(value == null){ //如果緩存中沒有釋放讀鎖,上寫鎖
rwl.readLock().unlock();
rwl.writeLock().lock();
try{
if(value == null){
value ="aaa"; //此時可以去數據庫中查找,這裏簡單的模擬一下
}
}finally{
rwl.writeLock().unlock();//釋放寫鎖
}
rwl.readLock().lock(); //然後再上讀鎖
}
}finally{
rwl.readLock().unlock(); //最後釋放讀鎖
}
return value;
}
}