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();
        }

    }
}

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