本文可作为传智播客《张孝祥-Java多线程与并发库高级利用》的学习笔记。
这1节我们做1个缓存系统。
在读本节前
请先浏览
ReentrantReadWriteLock读写锁的使用1
初版
public class CacheDemo {
private Map<String, Object> cache = new HashMap<String, Object>();
public static void main(String[] args) {
CacheDemo cd = new CacheDemo();
System.out.println("ss "+cd.getData2("ss"));
System.out.println("ss "+cd.getData2("ss"));
System.out.println("mm "+cd.getData2("mm"));
System.out.println("mm "+cd.getData2("mm"));
}
public Object getData2(String key){
Object o=cache.get(key);
if (o==null) { //标识1
System.out.println("第1次查 没有"+key);
o=Math.random(); //实际上从
数据库中取得
cache.put(key, o);
}
return o;
}
}
运行结果:
第1次查 没有ss
ss 0.4045014284225158
ss 0.4045014284225158
第1次查 没有mm
mm 0.9994663041529088
mm 0.9994663041529088
似乎没有问题。
你觉得呢?
如果有3个线程同时第1次到了getData2()的标识1处(所查找的key也都1样),1检查o为null,然后就去查
数据库。在这类情况下,就等于3个线程查同1个key,然后都去了
数据库。
这明显是不公道的。
第2版 synchronized
最简单的办法
public synchronized Object getData2(String key){
//.....
}
第3版 锁
上1节我们提到了ReentrantLock可以替换synchronized,前者是1种更加面向对象的设计。那我们试试。
private Lock l=new ReentrantLock(); //l作为CacheDemo的成员变量
public Object getData3(String key) {
l.lock();
Object o=null;
try {
o = cache.get(key);
if (o == null) { // 标识1
System.out.println("第1次查 没有" + key);
o = Math.random(); // 实际上从
数据库中取得
cache.put(key, o);
}
} finally {
l.unlock();
}
return o;
}
第3版可以吗?
可以个p。
为何,自己想。
我们得使用ReentrantReadWriteLock,在同1个方法中既有读锁也有写锁。
首先我又1个问题:
对同1个线程,可以在加了读锁后,没有解开读锁前,再加写锁吗?
换句话说,下面的代码会停吗?
public class CacheDemo {
private Map<String, Object> cache = new HashMap<String, Object>();
private ReadWriteLock rwl = new ReentrantReadWriteLock();
public static void main(String[] args) {
CacheDemo cd = new CacheDemo();
cd.getData2();
}
public void getData2(){
rwl.readLock().lock();
System.out.println(1);
rwl.writeLock().lock();
System.out.println(2);
rwl.readLock().unlock();
System.out.println(3);
rwl.writeLock().unlock();
System.out.println(4);
}
}
亲身试1下,控制台输出1后,程序就不动了。
说明加写锁前,读锁得先解开。
第4版
即有读锁,又有写锁
public static void main(String[] args) {
CacheDemo cd = new CacheDemo();
System.out.println("ss "+cd.getData4("ss"));
System.out.println("ss "+cd.getData4("ss"));
System.out.println("mm "+cd.getData4("mm"));
System.out.println("mm "+cd.getData4("mm"));
}
public Object getData4(String key){
rwl.readLock().lock();
Object o=null;
try {
o=cache.get(key);
if (o==null) {
System.out.println("第1次查 没有"+key);
rwl.readLock().unlock(); //标识4
rwl.writeLock().lock();
try {
if(value==null){ //标识0
value = "aaaa";//实际调用 queryDB();
cache.put(key,value);
}
} finally {
rwl.writeLock().unlock();
}
rwl.readLock().lock(); //标识1
}
}finally {
rwl.readLock().unlock(); //标注2
}
return o;
}
结果
第1次查 没有ss
ss 0.5989899889645358
ss 0.5989899889645358
第1次查 没有mm
mm 0.8534424949014686
mm 0.8534424949014686
这个还有3个问题
1为何在标识2处还得解锁。
这个答案在上1节已提过。
2为何在标识1出还得加锁?
如果标识1处不加锁,且程序1直正常履行,那末到标识2处,它解谁的锁?
3为何标识0出还要检查1次?
如果同时又3个线程运行到标识4(查找相同的key),其中1个取得写锁,写入数据后,释放了写锁。此时另外两个线程还需要去
数据库跑1趟么?
另外把标识1处的加读锁,放到finally的前面称之为降级锁。对降级锁,我目前也不太清楚。
官方文档中给了1个例子就是关于降级锁,以下
class CachedData {
Object data;
volatile boolean cacheValid;
final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
void processCachedData() {
rwl.readLock().lock();
if (!cacheValid) {
// Must release read lock before acquiring write lock
rwl.readLock().unlock();
rwl.writeLock().lock();
try {
// Recheck state because another thread might have
// acquired write lock and changed state before we did.
if (!cacheValid) {
data = ...
cacheValid = true;
}
// Downgrade by acquiring read lock before releasing write lock
rwl.readLock().lock();
} finally {
rwl.writeLock().unlock(); // Unlock write, still hold read
}
}
try {
use(data);
} finally {
rwl.readLock().unlock();
}
}
}
感谢glt