【并发编程】面试官：有没有比读写锁更快的锁？

最新推荐文章于 2024-04-27 18:21:36 发布

2401_84407849

最新推荐文章于 2024-04-27 18:21:36 发布

阅读量834

点赞数 11

分类专栏：程序员文章标签： spring java 后端

本文链接：https://blog.csdn.net/2401_84407849/article/details/137982866

版权

程序员专栏收录该内容

81 篇文章 0 订阅

订阅专栏

面试官：那有没有比读写锁更快的锁呢？

小明：。。。。。。。。。。

我靠，问的这么深的吗？小明当时就蒙蔽了，因为它项目中使用比较多的就是synchronized，读写锁都很少用到，因为很少牵扯到多线程问题，这个面试让他知道了多线程的重要性。

什么是读写锁

=====================================================================

读写锁：允许多个线程同时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态，读锁和写锁也是互斥的，所以在读的时候是不允许写的，那如何实现一个读写锁呢？

请参考：java并发编程之ReentrantReadWriteLock读写锁。

读写锁比传统的synchronized速度要快很多，原因就是在于读写锁支持读并发，而synchronized要求所有操作都是串行化，举个例子，我需要查询某个用户的基本信息，这些信息很少发生变化，所以我们会将这部分信息存放到缓存中，我们的查询操作为：

Created with Raphaël 2.2.0 开始查询缓存缓存中是否存在数据？结束查询数据库添加到缓存 yes no

按照上面流程图，如果使用synchronized的时候，查询缓存都会阻塞，但是使用读写锁，查询缓存时并发的，查询数据库是阻塞的，所以，读写锁在读多写少的情况下，性能明显要优于synchronized。

人类的文明在进步，java也在进步，对知识的渴望也在不断的增加，所以我们就不断的在想这么一个问题，读写锁的读和写是互斥，那我们能不能做到读和写支持并发呢？

在这里插入图片描述

StampedLock横空出世

==============================================================================

StampedLock其实是对读写锁的一种改进，它支持在读同时进行一个写操作,也就是说，它的性能将会比读写锁更快。

更通俗的讲就是在读锁没有释放的时候是可以获取到一个写锁，获取到写锁之后，读锁阻塞，这一点和读写锁一致，唯一的区别在于读写锁不支持在没有释放读锁的时候获取写锁。

StampedLock三种模式

悲观读：与读写锁的读写类似，允许多个线程获取悲观读锁
写锁：与读写锁的写锁类似，写锁和悲观读是互斥的。
乐观读：无锁机制，类似于数据库中的乐观锁，它支持在不释放乐观读的时候是可以获取到一个写锁的，这点和读写锁不同。

基本语法

我们先来看看悲观读于与写锁的基本语法

//获取悲观读

long stamp = lock.readLock();

try{

String info = mapCache.get(name);

if(null != info){

return info;

}

}finally {

//释放悲观读

lock.unlock(stamp);

}

//获取写锁

stamp = lock.writeLock();

try{

//判断一下缓存中是否被插入了数据

String info = mapCache.get(name);

if(null != info){

return info;

}

//这里是往数据库获取数据

String infoByDb = mapDb.get(name);

//讲数据插入缓存

mapCache.put(name,infoByDb);

}finally {

//释放写锁

lock.unlock(stamp);

}

我们看到，StampedLock语法和读写锁ReentrantReadWriteLock有了一点点区别，

获取锁的返回值：

StampedLock：long

ReentrantReadWriteLock：Lock

释放锁的方式：

StampedLock：unlock(stamp),需要传入获取锁返回的那个long值。

ReentrantReadWriteLock：unlock(),直接调用unlock方法即可。

StampedLock完整的demo

package com.ymy.test;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.locks.StampedLock;

public class StampedLockTest {

private static final StampedLock lock = new StampedLock();

//缓存中存储的数据

private static Map<String,String> mapCache = new HashMap<String, String>();

//模拟数据库存储的数据

private static Map<String,String> mapDb = new HashMap<String, String>();

static {

mapDb.put(“zhangsan”,“你好，我是张三”);

mapDb.put(“sili”,“你好，我是李四”);

}

private static String getInfo(String name){

//获取悲观读

long stamp = lock.readLock();

try{

String info = mapCache.get(name);

if(null != info){

System.out.println(“在缓存中获取到了数据”);

return info;

}

}finally {

//释放悲观读

lock.unlock(stamp);

}

//获取写锁

stamp = lock.writeLock();

try{

//判断一下缓存中是否被插入了数据

String info = mapCache.get(name);

if(null != info){

System.out.println(“获取到了写锁，再次确认在缓存中获取到了数据”);

return info;

}

//这里是往数据库获取数据

String infoByDb = mapDb.get(name);

//讲数据插入缓存

mapCache.put(name,infoByDb);

System.out.println(“缓存中没有数据，在数据库获取到了数据”);

}finally {

//释放写锁

lock.unlock(stamp);

}

return null;

}

public static void main(String[] args) {

//线程1

Thread t1 = new Thread(() ->{

getInfo(“zhangsan”);

});

//线程2

Thread t2 = new Thread(() ->{

getInfo(“zhangsan”);

});

//线程启动

t1.start();

t2.start();

//线程同步

try {

t1.join();

t2.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

这是悲观读+写锁的使用方式，达到的效果与读写锁（ReentrantReadWriteLock）是一样的，我们一起来验证一下，我将代码稍微做了一点改动，打印了两个线程的执行日志，同时当调用线程是zhangsan的时候休眠三秒，目的是为了看lisi的线程能否成功的获取到写锁，代码如下

package com.ymy.test;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.locks.StampedLock;

import java.util.logging.Logger;

public class StampedLockTest {

private static Logger log = Logger.getLogger(StampedLockTest.class.getName());

private static final StampedLock lock = new StampedLock();

//缓存中存储的数据

private static Map<String,String> mapCache = new HashMap<String, String>();

//模拟数据库存储的数据

private static Map<String,String> mapDb = new HashMap<String, String>();

static {

mapDb.put(“zhangsan”,“你好，我是张三”);

mapDb.put(“sili”,“你好，我是李四”);

}

private static String getInfo(String name){

//获取悲观读

long stamp = lock.readLock();

log.info(“线程名：”+Thread.currentThread().getName()+" 获取了悲观读锁" +" 用户名："+name);

try{

if(“zhangsan”.equals(name)){

log.info(“线程名：”+Thread.currentThread().getName()+" 休眠中" +" 用户名："+name);

Thread.sleep(3000);

log.info(“线程名：”+Thread.currentThread().getName()+" 休眠结束" +" 用户名："+name);

}

String info = mapCache.get(name);

if(null != info){

log.info(“在缓存中获取到了数据”);

return info;

}

} catch (InterruptedException e) {

log.info(“线程名：”+Thread.currentThread().getName()+" 释放了悲观读锁");

e.printStackTrace();

} finally {

//释放悲观读

lock.unlock(stamp);

}

//获取写锁

stamp = lock.writeLock();

log.info(“线程名：”+Thread.currentThread().getName()+" 获取了写锁" +" 用户名："+name);

try{

//判断一下缓存中是否被插入了数据

String info = mapCache.get(name);

if(null != info){

log.info(“获取到了写锁，再次确认在缓存中获取到了数据”);

return info;

}

//这里是往数据库获取数据

String infoByDb = mapDb.get(name);

//讲数据插入缓存

mapCache.put(name,infoByDb);

log.info(“缓存中没有数据，在数据库获取到了数据”);

}finally {

//释放写锁

log.info(“线程名：”+Thread.currentThread().getName()+" 释放了写锁" +" 用户名："+name);

lock.unlock(stamp);

}

return null;

}

public static void main(String[] args) {

//线程1

Thread t1 = new Thread(() ->{

getInfo(“zhangsan”);

});

//线程2

Thread t2 = new Thread(() ->{

getInfo(“lisi”);

});

//线程启动

t1.start();

t2.start();

//线程同步

try {

t1.join();

t2.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

如果在zhansan的线程休眠阶段李四的线程获取到了写锁，那么代表悲观读和写锁不是互斥的，反之互斥，请看代码运行结果：

三月 29, 2020 11:30:58 上午 com.ymy.test.StampedLockTest getInfo

信息: 线程名：Thread-2 获取了悲观读锁用户名：lisi

三月 29, 2020 11:30:58 上午 com.ymy.test.StampedLockTest getInfo

信息: 线程名：Thread-1 获取了悲观读锁用户名：zhangsan

三月 29, 2020 11:30:58 上午 com.ymy.test.StampedLockTest getInfo

信息: 线程名：Thread-1 休眠中用户名：zhangsan