前言
我们在大多数业务中遇到并发问题,最先想到的是,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();
}
}
}
可以发现我们的写操作依然是阻塞的,但是我们的读取操作已经可以并发进行,在性能上相比于之前的锁有了很大的提高。