美团面试官：有没有比读写锁更快的锁？

﹏ヽ暗。殇╰゛Y 2023-02-17 01:16 98阅读 0赞

互联网架构小马哥 2020-04-01 22:00:45

# 面试三连 #

面试官：了解锁吗？

小明：了解，还经常用过。

面试官：说说synchronized 和 lock 的区别吧

小明：

synchronized是可重入锁；由于lock是一个接口，重入性取决于实现。

synchronized不支持中断；而lock可以。

面试官：好了，那有没有比这两种锁更快的锁呢？

小明：在读多写少的情况下，读写锁比他们的效率更高。

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

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

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

# 什么是读写锁 #

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

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

![美团面试官：有没有比读写锁更快的锁？][format_png]

按照上面流程图，如果使用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
> 
> 三月 29, 2020 11:31:01 上午  
> com.ymy.test.StampedLockTest getInfo
> 
> 信息: 线程名：Thread-1 休眠结束 用户名：zhangsan
> 
> 三月 29, 2020 11:31:01 上午  
> com.ymy.test.StampedLockTest getInfo
> 
> 信息: 线程名：Thread-1 获取了写锁 用户名：zhangsan
> 
> 三月 29, 2020 11:31:01 上午  
> com.ymy.test.StampedLockTest getInfo
> 
> 信息: 缓存中没有数据，在数据库获取到了数据
> 
> 三月 29, 2020 11:31:01 上午  
> com.ymy.test.StampedLockTest getInfo
> 
> 信息: 线程名：Thread-1 释放了写锁 用户名：zhangsan
> 
> 三月 29, 2020 11:31:01 上午  
> com.ymy.test.StampedLockTest getInfo
> 
> 信息: 线程名：Thread-2 获取了写锁 用户名：lisi
> 
> 三月 29, 2020 11:31:01 上午  
> com.ymy.test.StampedLockTest getInfo
> 
> 信息: 缓存中没有数据，在数据库获取到了数据
> 
> 三月 29, 2020 11:31:01 上午  
> com.ymy.test.StampedLockTest getInfo
> 
> 信息: 线程名：Thread-2 释放了写锁 用户名：lisi
> 
>

我们仔细看打印日志的输出时间， 11:30:58 lisi和zhangsan都获取到了悲观读锁，并且zhangsan开始休眠，然后11:31:01的时候休眠结束，zhangsan获取到了写锁，所以悲观读与写锁肯定是互斥的，那这样的效率不是和读写锁一样吗？为什么说它比读写锁更快呢？这不是矛盾吗？

客官，别急啊，要记住精彩的永远在最后，StampedLock特锁模式我们只用了其中的两个，还有一个没有出场呢，下面我们来看看乐观读。

# 让StampedLock性能更上一楼的乐观读 #

**乐观读并不是一种锁，**所以请不要和悲观读联系在一起，**它是一种无锁机制，**相当于java的原子类操作，所以理论上性能会比读写锁（ReentrantReadWriteLock）更快一点，但不绝对。

当乐观读读取了成员变量的时候，需要将变量赋值给局部变量，然后再判断程序运行期间是否存在写锁，如果存在，升级为悲观读。

我们一起来看一下乐观读的实现：

> package com.ymy.test;
> 
> import java.util.concurrent.locks.StampedLock;
> 
> public class NumSumTest \{
> 
> private static final StampedLock lock = new StampedLock();
> 
> private static int num1 = 1;
> 
> private static int num2 = 1;
> 
> /\*\*
> 
> \* 修改成员变量的值，+1
> 
> \*
> 
> \* @return
> 
> \*/
> 
> private static int sum() \{
> 
> System.out.println("求和方法被执行了");
> 
> **//获取乐观读**
> 
> **long stamp = lock.tryOptimisticRead();**
> 
> int cnum1 = num1;
> 
> int cnum2 = num2;
> 
> System.out.println("获取到的成员变量值,cnum1：" + cnum1 + " cnum2：" + cnum2);
> 
> try \{
> 
> //休眠3秒，目的是为了让其他线程修改掉成员变量的值。
> 
> Thread.sleep(3000);
> 
> \} catch (InterruptedException e) \{
> 
> e.printStackTrace();
> 
> \}
> 
> **//判断在运行期间是否存在写操作 true：不存在； false：存在**
> 
> **if (!lock.validate(stamp)) \{** 
> 
> System.out.println("存在写操作！");
> 
> //存在写锁
> 
> //升级悲观读锁
> 
> stamp = lock.readLock();
> 
> try \{
> 
> System.out.println("升级悲观读锁");
> 
> cnum1 = num1;
> 
> cnum2 = num2;
> 
> System.out.println("重新获取了成员变量的值=========== cnum1="+cnum1 +" cnum2="+cnum2);
> 
> \} finally \{
> 
> //释放悲观读锁
> 
> lock.unlock(stamp);
> 
> \}
> 
> \}
> 
> return cnum1 + cnum2;
> 
> \}
> 
> //使用写锁修改成员变量的值
> 
> private static void updateNum() \{
> 
> long stamp = lock.writeLock();
> 
> try \{
> 
> num1 = 2;
> 
> num2 = 2;
> 
> \} finally \{
> 
> lock.unlock(stamp);
> 
> \}
> 
> \}
> 
> public static void main(String\[\] args) throws InterruptedException \{
> 
> Thread t1 = new Thread(() -> \{
> 
> int sum = sum();
> 
> System.out.println("求和结果：" + sum);
> 
> \});
> 
> t1.start();
> 
> //休眠1秒，目的为了让线程t1能执行到获取成员变量之后
> 
> Thread.sleep(1000);
> 
> updateNum();
> 
> t1.join();
> 
> System.out.println("执行完毕");
> 
> \}
> 
> \}

解释代码，定义了两个成员变量，让后利用t1线程去计算两个成员变量的和，为了能体现出乐观读的效果，我在sum()中休眠了3秒，目的是让main主线程去修改掉成员变量的值，main函数中的休眠是为了让t1线程能准确地执行到读取成员变量阶段。

**我们来看看执行的结果：**

> 求和方法被执行了
> 
> 获取到的成员变量值,cnum1：1 cnum2：1
> 
> 存在写操作！
> 
> 升级悲观读锁
> 
> 重新获取了成员变量的值=========== cnum1=2 cnum2=2
> 
> 求和结果：4
> 
> 执行完毕

我们发现，t1首先读取了两个成员变量的值，然后发现了存在写操作，那是因为main函数利用写锁修改了两个成员变量的值，这个时候升级为了悲观读，再次获取成员变量的值，然后再计算两个值的和，为什么要升级悲观读锁呢？因为再文章开头的时候说过悲观读锁与写锁互斥，悲观读锁之前并行，所以乐观读升级到悲观读锁之后再获取一次成员变量，可以保证再当前悲观读锁中数据是线程安全的。

# 你了解乐观读的应用场景吗 #

乐观读并不是StampedLock的专利，有很多地方都使用到了乐观读，比如数据库的乐观锁悲观锁，java并发工具的原子类工具。

数据库悲观锁与乐观锁可以参考：mysql：悲观锁与乐观锁

java 并发工具原子类参考：java并发编程：CAS(Compare and Swap)

# 使用StampedLock的注意事项 #

1.**StampedLock属于ReadWriteLock的子类，ReentrantReadWriteLock也是属于ReadWriteLock的子类，**你们发现他们的区别了吗？看名字就能看出来**StampedLock不支持重入锁。**

2.它适用于读多写少的情况，如果不是这中情况，请慎用，性能可能还不如synchronized。

3.StampedLock的悲观读锁、写锁不支持条件变量。

4.千万不能中断阻塞的悲观读锁或写锁，如果调用阻塞线程的interrupt()，会导致cpu飙升，如果希望StampedLock支持中断操作，请使用readLockInterruptibly（悲观读锁）与writeLockInterruptibly（写锁）。

# 总结 #

**在读多写少的情况下推荐使用StampedLock，因为它的乐观读，**性能比读写锁提升了很多，但是再其他应用场景中，使用它还需要慎重。

**乐观读支持并发一个写锁，**而悲观读和写锁互斥，所以在使用过程中，我们可以先使用乐观读。然后判断是否存在写锁，如果存在，可以升级悲观读锁，由于悲观读锁和写锁的互斥性，他能保证线程的安全性问题，如果小明再平时的时候多看看我的博客的话，可能就不会被这个问题难住了。

感谢各位靓仔/靓女的观看！看完记得给小弟来个转发关注哦~

> 原文链接：  
> https://blog.csdn.net/qq\_33220089/article/details/105173632

[format_png]: https://imgconvert.csdnimg.cn/aHR0cDovL3A5LnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzc0N2M2YzM2OTY4MzRiYTk4MTYzNmJhYWI0MmFmMDVk?x-oss-process=image/format,png