ReentrantReadWriteLock 实现手写缓存，并发读取、阻塞添加

前言

我们在大多数业务中遇到并发问题，最先想到的是，Synchorized,以及 ReentrantLock，但是这两种锁是重量级的，也是阻塞的锁，一个线程获取了锁，其他线程必须阻塞，并发性能大大降低。

今天我们来介绍一下java.util.concurrent.locks包下面的另一把锁：ReentrantReadWriteLock 读写锁，顾名思义，就是可以区分读还是写操作，展现不同的锁类型，做到并发读取，阻塞写入，使性能大大提升。

案例

本文我们使用一个简单的手写缓存Demo来展示一下锁的特性以及功能。

package com.cpown.demo.lockdemo; import lombok.extern.slf4j.Slf4j; 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; /** * 利用读写锁实现缓存并发 * 并发读，阻塞写 */ @Slf4j public class ReadWriteMapCache { /** * 缓存数据存放Map */ private volatile Map<String,Object> cashMap = new HashMap<>(); /** * 插入数据 * @param key * @param value */ public void put(String key,Object value){ log.info("开始插入数据："+ key+Thread.currentThread().getName()); cashMap.put(key,value); log.info("插入数据成功："+ key+Thread.currentThread().getName()); } /** * 读取数据 * @param key */ public void get(String key){ log.info("开始读取数据："+ key +"/t"+ Thread.currentThread().getName()); Object result = cashMap.get(key); log.info("读取数据成功："+ result +"/t"+ Thread.currentThread().getName()); } } /** * 测试demo */ class ReadWriteDemo{ public static void main(String[] args) { ReadWriteMapCache cache = new ReadWriteMapCache(); for (int i = 0; i < 5; i++) { final int num = i; new Thread(() ->{ try { cache.put(num+"",num+""); TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } },"插入线程："+i).start(); } for (int i = 0; i < 5; i++) { final int num = i; new Thread(() ->{ try { cache.get(num+""); TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } },"读取线程："+i).start(); } } }

首先我们看一下上面的代码，我们手写了一个缓存Demo，通过线程并发往缓存Map里面添加以及读取数据： 在没有加锁的情况下，我们的读取完全混乱： 首先我们使用synchronized修饰 插入与存取方法：

/** * 插入数据 * @param key * @param value */ public synchronized void put(String key,Object value){ log.info("开始插入数据："+ key+Thread.currentThread().getName()); cashMap.put(key,value); log.info("插入数据成功："+ key+Thread.currentThread().getName()); } /** * 读取数据 * @param key */ public synchronized void get(String key){ log.info("开始读取数据："+ key +"/t"+ Thread.currentThread().getName()); Object result = cashMap.get(key); log.info("读取数据成功："+ result +"/t"+ Thread.currentThread().getName()); }

效果是可行的，但是在我们所有的读取以及写入操作都是阻塞的，这与我们要求的并发性能还是存在差异。

下面修改代码 使用ReentrantReadWriteLock ：

/** * 利用读写锁实现缓存并发 * 并发读，阻塞写 */ @Slf4j public class ReadWriteMapCache { /** * 缓存数据存放Map */ private volatile Map<String,Object> cashMap = new HashMap<>(); /** * 使用读写锁 */ private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); /** * 插入数据 * @param key * @param value */ public void put(String key,Object value){ //加入写锁 lock.writeLock().lock(); try { log.info("开始插入数据："+ key+Thread.currentThread().getName()); cashMap.put(key,value); log.info("插入数据成功："+ key+Thread.currentThread().getName()); } catch (Exception e) { e.printStackTrace(); }finally { lock.writeLock().unlock(); } } /** * 读取数据 * @param key */ public void get(String key){ //加入读锁 lock.readLock().lock(); try { log.info("开始读取数据："+ key + Thread.currentThread().getName()); Object result = cashMap.get(key); log.info("读取数据成功："+ result + Thread.currentThread().getName()); } catch (Exception e) { e.printStackTrace(); }finally { lock.readLock().unlock(); } } }

可以发现我们的写操作依然是阻塞的，但是我们的读取操作已经可以并发进行，在性能上相比于之前的锁有了很大的提高。