JUC并发系列(十)：超全透彻ReadWriteLock读写锁（应用场景+代码示例+关键代码剖析）

跑起一个程序，并不难；难的是，能让程序跑多远！—— 一颗剽悍的种子

JUC并发系列

JUC并发系列(一)：什么？听说你搞混了并发和并行
JUC并发系列(二)：详解Condition实现精准通知唤醒
JUC并发系列(三)：面试问并发，一问锁就懵（怒肝一篇透彻理解锁，面试不慌）
JUC并发系列(四)：【面试常问】多种方法解决ArrayList非线程安全，详解CopyOnWriteArrayList
JUC并发系列(五)：CopyOnWriteArraySet解决HashSet非线程安全
JUC并发系列(六)：ConcurrentHashMap解决HashMap非线程安全
JUC并发系列(七)：触及Callable
JUC并发系列(八)：并发编程常用辅助类CountDownLatch与CyclicBarrier
JUC并发系列(九)：并发编程常用辅助类Semaphore

一、什么是 ReadWriteLock读写锁？

准确来说 ReadWriteLock读写锁，应该是 读/写锁，正如ReadWriteLock 读/写锁也是分开来的，它管理着两个为一组的锁，一个是只读锁，一个是写锁。

通过字面意思告诉你 ReadWriteLock读/写锁 其实你是很难理解的，因为只有通过案例，只有通过一行行代码去验证，你才能在深深的理解后有自己的总结。

有自己总结过后的知识才是你的，因为那是知识的结晶。

（技术之余总会扯这些有的没的，只想告诉你不要光看我的博文，学习这种活，也只有你理解透后，用自己所能理解的语言重塑，才是你自己的。）

我们接下来用两个小案例，首先是一个没有使用锁和使用ReadWriteLock读写锁后的形式对比来学习。

二、手敲代码示例——并发下的缓存

我们通过一个缓存的小案例来，在没有使用锁的情况下，实现存储和读取的功能，并通过在多个线程的并发下。

public class Demo{
    public static void main(String[] args) {
        Cache cache = new Cache();
        //存储
        for (int i = 1; i <= 3; i++) {
            final Integer index = i;
            new Thread(()->{
                cache.put(index+"",index);
            },String.valueOf(i)).start();
        }
        //读取
        for (int i = 1; i <= 3; i++) {
            final Integer index = i;
            new Thread(()->{
                cache.get(index+"");
            },String.valueOf(i)).start();
        }
    }
}
class Cache{
    private Map<String,Integer> map = new HashMap<>();
    //存储
    public void put(String key,Integer value){
        System.out.println("线程"+Thread.currentThread().getName() + "===存储" + value);
        map.put(key,value);
        System.out.println("线程"+Thread.currentThread().getName() + "===已存储");
    }
    //读取
    public void get(String key){
        System.out.println("线程"+Thread.currentThread().getName() + "===读取");
        map.get(key);
        System.out.println("线程"+Thread.currentThread().getName() + "===已读取");
    }
}

三、运行结果

四、分析结果

观察上面的代码所运行的结果会发现两点：

1. 当线程1在存储时被其他线程插入。

2. 每次执行的结果都跟上一次不一致。

五、关键代码剖析：读/写锁里的独占锁与共享锁

如果你理解了上面为什么ReadWriteLock读/写锁是分成两个为一组的读/写，其实你在实际运用中也就能更深刻透彻。

我们缓存 put 是存储就是写入，可以用 writeLock写锁。

而读取 get 可以用读锁。

可以看到不会像synchronized直接锁或lock，它们更加细致，也更具有针对性的分而治之。

这里的写锁可以说是共享锁，独占锁又称排他锁。

共享锁（写锁）：一次只能一个线程持有。

readWriteLock.writeLock().lock();

共享锁（读锁）：多个线程可以同时持有。

readWriteLock.readLock().lock();

读/写锁使用后都需要分别关闭，跟Lock最后也需要手动关闭是一样一样的。

readWriteLock.writeLock().unlock();

readWriteLock.readLock().unlock();

六、使用ReadWriteLock读/写锁解决缓存并发问题

public class Demo{
    public static void main(String[] args) {
        Cache cache = new Cache();
        //存储
        for (int i = 1; i <= 3; i++) {
            final Integer index = i;
            new Thread(()->{
                cache.put(index+"",index);
            },String.valueOf(i)).start();
        }
        //读取
        for (int i = 1; i <= 3; i++) {
            final Integer index = i;
            new Thread(()->{
                cache.get(index+"");
            },String.valueOf(i)).start();
        }
    }
}
class Cache{
    private Map<String,Integer> map = new HashMap<>();
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //存储
    public void put(String key,Integer value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println("线程"+Thread.currentThread().getName() + "===存储" + value);
            map.put(key,value);
            System.out.println("线程"+Thread.currentThread().getName() + "===已存储");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
    //读取
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println("线程"+Thread.currentThread().getName() + "===读取");
            map.get(key);
            System.out.println("线程"+Thread.currentThread().getName() + "===已读取");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

七、运行结果（漂亮）

可以看到和上面没有加锁的运行结果，加了ReadWriteLock读写锁 后很直观的结果。在多线程并发下存储的时候会有秩序的执行。

八、应用场景

从 ReadWriteLock读/写锁 的不仅概念或者案例的对比和验证中可以很直观的发现其特性。

使用 ReadWriteLock读/写锁 时， 适用少数线程修改操作，但可以有大量线程读取。

所以可以运用的场景有很多很多，例如，CSDN里的每一篇博文底下都有 评论与回复，可以看做是 写入操作，它是不频繁；但是，读取操作，也就是 浏览，是非常频繁的，这种类型的应用场景可以使用ReadWriteLock读/写锁

九、最后

最后的最后，为了更好的阅读体验，我把想说的话都放在了下面，嘿嘿。

我是一颗剽悍的种子 把我会的，认真的分享 是我写博客一直不变的信条。
如果你能看到这篇博文，说明咱们还是很有缘的；希望能带给你一些许帮助，创作的不易， 把我文章的知识带走，你的三连留下，点赞，评论，关注，是我最大的动力。