美团面试官:有没有比读写锁更快的锁?

4,868 阅读12分钟

面试三连

面试官:了解锁吗?

小明:了解,还经常用过。

面试官:说说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的注意事项

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

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

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

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

总结

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

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

感谢各位靓仔/靓女的观看!看完记得给小弟来个点赞关注哦~

最后

需要大厂精选面试题及答案、Java架构师的学习资料及学习视频的程序员朋友可以点赞+关注后点击此处免费领取得到,各位看官记得点赞关注一下哈~

(文末福利:马士兵大佬网约车项目实战白皮书)

高级开发架构学习资料

源码实战书籍

华为社招面试攻略:Redis中是如何实现分布式锁的?

中高级架构视频全套视频

华为社招面试攻略:Redis中是如何实现分布式锁的?

文中提及内容获取方式:点赞+关注后点击此处免费领取得到

大厂面试宝典

华为社招面试攻略:Redis中是如何实现分布式锁的?


点赞+关注后点击此处免费领取得到架构视频,大厂面试攻略,高清架构学习视频以及马大佬的网约车项目实战文档~

网约车项目

华为社招面试攻略:Redis中是如何实现分布式锁的?