现实中有这样一种场景:对共享资源有读和写的操作,且写操作没有读操作那么频繁。在没有写操作的时候,多个线程同时读一个资源没有任何问题,所以应该允许多个线程同时读取共享资源;但是如果一个线程想去写这些共享资源,就不应该允许其他线程对该资源进行读和写的操作了。
针对这种场景,JAVA 的并发包提供了读写锁 ReentrantReadWriteLock
,它表示两个锁,一个是读操作相关的锁,称为共享锁;一个是写相关的锁,称为排他锁。
线程进入读锁的条件:
线程进入写锁的前提条件:
读写锁有以下三个重要的特性:
场景:使用读写锁对一个hashmap进行读和写操作
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
//资源类
class MyCache{
//创建Map集合
private volatile Map<String,Object> map=new HashMap<>();
//创建读写锁对象
private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();
//放数据
public void put(String key,Object value) {
//添加写锁
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName()+" 正在写操作"+key);
//暂停一会
TimeUnit.MICROSECONDS.sleep(300);
//放数据
map.put(key,value);
System.out.println(Thread.currentThread().getName()+" 写完了"+key);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//释放写锁
readWriteLock.writeLock().unlock();
}
}
//取数据
public Object get(String key) {
//添加读锁
readWriteLock.readLock().lock();
Object result= null;
try {
result = null;
System.out.println(Thread.currentThread().getName()+" 正在读操作"+key);
//暂停一会
TimeUnit.MICROSECONDS.sleep(300);
result=map.get(key);
System.out.println(Thread.currentThread().getName()+" 取完了"+key);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//释放读锁
readWriteLock.readLock().unlock();
}
return result;
}
}
public class ReadWriteLockDemo {
public static void main(String[] args) throws InterruptedException {
MyCache myCache=new MyCache();
//创建线程放数据
for (int i = 1; i <=5 ; i++) {
final int num=i;
new Thread(()->{
myCache.put(num+"",num+"");
},String.valueOf(i)).start();
}
TimeUnit.MICROSECONDS.sleep(300);
//创建线程取数据
for (int i = 1; i <=5 ; i++) {
final int num=i;
new Thread(()->{
myCache.get(num+"");
},String.valueOf(i)).start();
}
}
}
测试在持有写锁的情况下试图获取读锁。
//演示读写锁降级
public class Demo1 {
public static void main(String[] args) {
//可重入读写锁对象
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();//读锁
ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();//写锁
//锁降级
//1、获取到写锁
writeLock.lock();
System.out.println("测试");
//2、获取到读锁
readLock.lock();
System.out.println("--read");
//3、释放写锁
writeLock.unlock();
//4、释放读锁
readLock.unlock();
}
}
没有任何问题,甚至可以先释放写锁,继续持有读锁,这样一个“写锁”就降级为了读锁。
【1】在线程持有读锁的情况下,该线程不能取得写锁(因为获取写锁的时候,如果发现当前的读锁被占用,就马上获取失败,不管读锁是不是被当前线程持有)。 【2】在线程持有写锁的情况下,该线程可以继续获取读锁(获取读锁时如果发现写锁被占用,只有写锁没有被当前线程占用的情况才会获取失败)。 原因:当线程获取读锁的时候,可能有其他线程也在持有读锁,因此不能把获取读锁的线程“升级”为写锁;而对于获得写锁的线程,它一定独占了读写锁,因此可以继续让他获取读锁,当它同时获取了写锁和读锁后,还可以先释放写锁继续持有读锁,这样一个写锁就“降级”为了读锁。