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在存储时被其他线程插入。

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

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

如果你理解了上面为什么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读/写锁 时， 适用少数线程修改操作，但可以有大量线程读取。

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

九、最后

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

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