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

面试三连问

面试官：了解锁吗？

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

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

小明：synchronized是可重入锁，因为lock是一个接口，重入性取决于实现，synchronized不支持中断，而lock能够……

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

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

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

小明：……

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

一、什么是读写锁

读写锁：容许多个线程同时读，可是只容许一个线程写，在线程获取到写锁的时候，其余写操做和读操做都会处于阻塞状态，读锁和写锁也是互斥的，因此在读的时候是不容许写的，那如何实现一个读写锁呢？

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

按照上面流程图，若是使用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的注意事项

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

二、它适用于读多写少的状况，若是不是这中状况，请慎用，性能可能还不如synchronized。

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

四、千万不能中断阻塞的悲观读锁或写锁，若是调用阻塞线程的interrupt()，会致使cpu飙升，若是但愿StampedLock支持中断操做，请使用readLockInterruptibly（悲观读锁）与writeLockInterruptibly（写锁）。

总结

在读多写少的状况下推荐使用StampedLock，由于它的乐观读，性能比读写锁提高了不少，可是再其余应用场景中，使用它还须要慎重。

乐观读支持并发一个写锁，而悲观读和写锁互斥，因此在使用过程当中，咱们能够先使用乐观读，而后判断是否存在写锁。

若是存在，能够升级悲观读锁，因为悲观读锁和写锁的互斥性，他能保证线程的安全性问题，若是小明在平时的时候多看看个人博客的话，可能就不会被这个问题难住了。

• END -

原文连接：

https://blog.csdn.net/qq_3322...

文源网络，仅供学习之用，若有侵权，联系删除。

我将面试题和答案都整理成了PDF文档，还有一套学习资料，涵盖Java虚拟机、spring框架、Java线程、数据结构、设计模式等等，但不只限于此。

关注公众号【java圈子】获取资料，还有优质文章每日送达。