ReentrantLock、ReentrantReadWriteLock、StampedLock讲解

一、 关于锁的面试题

        你知道Java里面有那些锁
        你说说你用过的锁，锁饥饿问题是什么？
        有没有比读写锁更快的锁
        StampedLock知道吗？（邮戳锁/票据锁）
        ReentrantReadWriteLock有锁降级机制，你知道吗？

      

二、简单聊聊ReentrantReadWriteLock

        1、是什么？

        读写锁说明：
        一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程

        再说说演变：
        无锁无序->加锁->读写锁->邮戳锁
        
        读写锁意义和特点：
        它只允许读读共存，而读写和写写依然是互斥的，大多实际场景是”读/读“线程间不存在互斥关系，只有”读/写“线程或者”写/写“线程间的操作是需要互斥的，因此引入了 ReentrantReadWriteLock
        一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但是不能同时存在写锁和读锁，也即资源可以被多个读操作访问，或一个写操作访问，但两者不能同时进行。
        只有在读多写少情景之下，读写锁才具有较高的性能体现。

        2、特点

        可重入
        读写兼顾
        结论：一体两面，读写互斥，读读共享，读没有完成的时候其他线程写锁无法获得

        锁降级：

        将写锁降级为读锁------>遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级为读锁
        1）如果一个线程持有了写锁，在没有释放写锁的情况下，它还可以继续获得读锁。这就是写锁的降级，降级成为了读锁。
        2）如果释放了写锁，那么就完全转换为读锁
        3）如果有线程在读，那么写线程是无法获取写锁的，是悲观锁的策略

        锁降级是为了让当前线程感知到数据的变化，目的是保证数据可见性
        如果有线程在读，那么写线程是无法获取写锁的，是悲观锁的策略
        在ReentrantReadWriteLock中，当读锁被使用时，如果有线程尝试获取写锁，该写线程会被阻塞。所以，需要释放所有读锁，才可获取写锁。
        写锁和读锁是互斥的(这里的互斥是指线程间的互斥，当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁)，这是因为读写锁要保持写操作的可见性。因为，如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作。
        ReentrantReadWriteLock读的过程中不允许写，只有等待线程都释放了读锁，当前线程才能获取写锁，也就是写入必须等待，这是一种悲观的读锁，人家还在读着那，你先别去写，省的数据乱。

        分析StampedLock(后面详细讲解)，会发现它改进之处在于:
        读的过程中也允许获取写锁介入(相当牛B，读和写两个操作也让你“共享”(注意引号))，这样会导致我们读的数据就可能不一致所以，需要额外的方法来判断读的过程中是否有写入，这是一种乐观的读锁。
        显然乐观锁的并发效率更高，但一旦有小概率的写入导致读取的数据不一致，需要能检测出来，再读一遍就行。

         3、为什么要锁降级?

        锁降级确实不太贴切，明明是锁切换，在写锁释放前由写锁切换成了读锁。问题的关键其实是为什么要在锁切换前就加上读锁呢？防止释放写锁的瞬间被其他线程拿到写锁然后修改了数据，然后本线程在拿到读锁后读取数据就发生了错乱。但是，我把锁的范围加大一点不就行了吗？在写锁的范围里面完成读锁里面要干的事。缺点呢就是延长了写锁的占用时长，导致性能下降。对于中小公司而言没必要，随便在哪都能把这点性能捡回来了！

 

        4、 锁饥饿问题

        ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，假如当前1000个线程，999个读,1个写，有可能999个读取线程长时间抢到了锁，那1个写线程就悲剧了因为当前有可能会一直存在读锁，而无法获得写锁，根本没机会写。

        如何缓解锁饥饿问题?
        使用"公平"策略可以一定程度上缓解这个问题，但是"公平"策略是以牺牲系统吞吐量为代价的
        StampedLock类的乐观读锁闪亮登场

三、邮戳锁StampedLock

        1、是什么

        StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化

        stamp 代表了锁的状态。当stamp返回零时，表示线程获取锁失败，并且当释放锁或者转换锁的时候，都要传入最初获取的stamp值。

        2、它是由饥饿问题引出

        ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。但是，StampedLock采取乐观获取锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化，所以，在获取乐观读锁后，还需要对结果进行校验。

        ReentrantReadWriteLock：
        允许多个线程向时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态，
        读锁和写锁也是互斥的，所以在读的时候是不允许写的，读写锁比传统的synchronized速度要快很多，原因就是在于ReentrantReadWriteLock支持读并发，读读可以共享。
        对短的只读代码段，使用乐观模式通常可以减少争用并提高吞吐量

        锁饥饿问题：
        ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，因此当前有可能会一直存在读锁，而无法获得写锁。

        如何解决锁饥饿问题：
        使用”公平“策略可以一定程度上缓解这个问题
        使用”公平“策略是以牺牲系统吞吐量为代价的
        StampedLock类的乐观读锁方式--->采取乐观获取锁，其他线程尝试获取写锁时不会被阻塞，在获取乐观读锁后，还需要对结果进行校验

        3、StampedLock的特点

        所有获取锁的方法，都返回一个邮戳，stamp为零表示失败，其余都表示成功
        所有释放锁的方法，都需要一个邮戳，这个stamp必须是和成功获取锁时得到的stamp一致
        StampedLock是不可重入的，危险（如果一个线程已经持有了写锁，在去获取写锁的话会造成死锁）

        StampedLock有三种访问模式：
        Reading（读模式悲观）：功能和ReentrantReadWriteLock的读锁类似
        Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似
        Optimistic reading（乐观读模式）：无锁机制，类似与数据库中的乐观锁，支持读写并发，很乐观认为读时没人修改，假如被修改在实现升级为悲观读模式

        一句话：读的过程中也允许写锁介入

        4、乐观读模式Code演示

        传统的读写锁模式----读的时候写锁不能获取

/*** @author Guanghao Wei* @create 2023-04-17 16:41*/
public class StampedLockDemo {static int number = 37;static StampedLock stampedLock = new StampedLock();public void write() {long stamp = stampedLock.writeLock();System.out.println(Thread.currentThread().getName() + "\t" + "写线程准备修改");try {number = number + 13;} finally {stampedLock.unlockWrite(stamp);}System.out.println(Thread.currentThread().getName() + "\t" + "写线程结束修改");}public void read() {long stamp = stampedLock.readLock();System.out.println(Thread.currentThread().getName() + "\t" + " come in readLock codeBlock");for (int i = 0; i < 4; i++) {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "\t" + " 正在读取中");}try {int result = number;System.out.println(Thread.currentThread().getName() + "\t" + "获得成员变量值result: " + result);System.out.println("写线程没有修改成功，读锁时候写锁无法介入，传统的读写互斥");} finally {stampedLock.unlockRead(stamp);}}public static void main(String[] args) {StampedLockDemo resource = new StampedLockDemo();new Thread(() -> {resource.read();}, "readThread").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(() -> {System.out.println(Thread.currentThread().getName()+"\t"+" come in");resource.write();}, "writeThread").start();}
}
/*** readThread	 come in readLock codeBlock* readThread	 正在读取中* writeThread	 come in* readThread	 正在读取中* readThread	 正在读取中* readThread	 正在读取中* readThread	获得成员变量值result: 37* 写线程没有修改成功，读锁时候写锁无法介入，传统的读写互斥* writeThread	写线程准备修改* writeThread	写线程结束修改*/

        

        乐观读模式----读的过程中也允许写锁介入

/*** @author Guanghao Wei* @create 2023-04-17 16:41*/
public class StampedLockDemo {static int number = 37;static StampedLock stampedLock = new StampedLock();public void write() {long stamp = stampedLock.writeLock();System.out.println(Thread.currentThread().getName() + "\t" + "写线程准备修改");try {number = number + 13;} finally {stampedLock.unlockWrite(stamp);}System.out.println(Thread.currentThread().getName() + "\t" + "写线程结束修改");}public void read() {long stamp = stampedLock.tryOptimisticRead();int result = number;System.out.println("4秒前 stampedLock.validate方法值（true 无修改 false有修改）" + "\t" + stampedLock.validate(stamp));for (int i = 0; i < 4; i++) {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "\t" + " 正在读取...." + i + "秒后" + "stampedLock.validate方法值（true 无修改 false有修改）" + "\t" + stampedLock.validate(stamp));}if (!stampedLock.validate(stamp)) {System.out.println("有人修改----------有写操作");stamp = stampedLock.readLock();try {System.out.println("从乐观读升级为悲观读");result = number;System.out.println("重新悲观读后result：" + result);} finally {stampedLock.unlockRead(stamp);}}System.out.println(Thread.currentThread().getName() + "\t" + "finally value: " + result);}public static void main(String[] args) {StampedLockDemo resource = new StampedLockDemo();new Thread(() -> {resource.read();}, "readThread").start();try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}new Thread(() -> {System.out.println(Thread.currentThread().getName() + "\t" + " come in");resource.write();}, "writeThread").start();}
}
/*** 4秒前 stampedLock.validate方法值（true 无修改 false有修改）	true* readThread	 正在读取....0秒后stampedLock.validate方法值（true 无修改 false有修改）	true* readThread	 正在读取....1秒后stampedLock.validate方法值（true 无修改 false有修改）	true* writeThread	 come in* writeThread	写线程准备修改* writeThread	写线程结束修改* readThread	 正在读取....2秒后stampedLock.validate方法值（true 无修改 false有修改）	false* readThread	 正在读取....3秒后stampedLock.validate方法值（true 无修改 false有修改）	false* 有人修改----------有写操作* 从乐观读升级为悲观读* 重新悲观读后result：50* readThread	finally value: 50*/

        5、StampedLock的缺点：

        StampedLock不支持重入，没有Re开头
        StampedLock的悲观读锁和写锁都不支持条件变量，这个也需要主要
        使用StampedLock一定不要调用中断操作，即不要调用interrupt()方法