ReentrantReadWriteLock读写锁的使用2

本文可作为传智播客《张孝祥-Java多线程与并发库高级应用》的学习笔记。

这一节我们做一个缓存系统。

在读本节前
请先阅读
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("第一次查  没有"+key);            o=Math.random();     //实际上从数据库中获得            cache.put(key, o);        }        return o;    }}

运行结果:
第一次查  没有ss
ss   0.4045014284225158
ss   0.4045014284225158
第一次查  没有mm
mm   0.9994663041529088
mm   0.9994663041529088

似乎没有问题。
你觉得呢?
如果有三个线程同时第一次到了getData2()的标识1处(所查找的key也都一样),一检查o为null,然后就去查数据库。在这种情况下,就等于三个线程查同一个key,然后都去了数据库。
这显然是不合理的。

第二版 synchronized

最简单的办法
    public synchronized Object getData2(String key){
        //.....

    }

第三版 锁

上一节我们提到了ReentrantLock可以替换synchronized,前者是一种更为面向对象的设计。那我们试试。

    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("第一次查  没有" + key);                o = Math.random(); // 实际上从数据库中获得                cache.put(key, o);            }        } finally {            l.unlock();        }        return o;    }

第三版可以吗?
可以个p。

为什么,自己想。

我们得使用ReentrantReadWriteLock,在同一个方法中既有读锁也有写锁。

首先我又一个问题:

对同一个线程,可以在加了读锁后,没有解开读锁前,再加写锁吗?

换句话说,下面的代码会停吗?

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后,程序就不动了。

说明加写锁前,读锁得先解开。

第四版

即有读锁,又有写锁
   

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("第一次查  没有"+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;    }                 

结果
第一次查  没有ss
ss   0.5989899889645358
ss   0.5989899889645358
第一次查  没有mm
mm   0.8534424949014686

mm   0.8534424949014686

这个还有三个问题

1为什么在标识2处还得解锁。
这个答案在上一节已经提过。

2为什么在标识1出还得加锁?
如果标识1处不加锁,且程序一直正常执行,那么到标识2处,它解谁的锁?


3为什么标识0出还要检查一次?
如果同时又三个线程运行到标识4(查找相同的key),其中一个获得写锁,写入数据后,释放了写锁。此时另外两个线程还需要去数据库跑一趟么?

另外把标识1处的加读锁,放到finally的前面称之为降级锁。对降级锁,我目前也不太清楚。
官方文档中给了一个例子就是关于降级锁,如下

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