13. ReentrantLock、ReentrantReadWriteLock、StampedLock讲解

心已赠人 2023-10-12 14:48 33阅读 0赞

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

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

13.2.2 特点  
● 可重入  
● 读写兼顾  
● 结论：一体两面，读写互斥，读读共享，读没有完成的时候其他线程写锁无法获得  
● 锁降级：  
**○ 将写锁降级为读锁------>遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级为读锁  
○ 如果一个线程持有了写锁，在没有释放写锁的情况下，它还可以继续获得读锁。这就是写锁的降级，降级成为了读锁。  
○ 如果释放了写锁，那么就完全转换为读锁  
○ 如果有线程在读，那么写线程是无法获取写锁的，是悲观锁的策略**  
![在这里插入图片描述][9cff7ac129c14e67bd2b502e62ae4b8b.png_pic_center]  
13.3 面试题：有没有比读写锁更快的锁？  
**13.4 邮戳锁StampedLock**  
13.4.1 是什么？  
StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化  
stamp 代表了锁的状态。当stamp返回零时，表示线程获取锁失败，并且当释放锁或者转换锁的时候，都要传入最初获取的stamp值。  
13.4.2 它是由饥饿问题引出  
● 锁饥饿问题：  
○ ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，因此当前有可能会一直存在读锁，而无法获得写锁。  
● 如何解决锁饥饿问题：  
○ 使用”公平“策略可以一定程度上缓解这个问题  
○ 使用”公平“策略是以牺牲系统吞吐量为代价的  
○ StampedLock类的乐观读锁方式—>采取乐观获取锁，其他线程尝试获取写锁时不会被阻塞，在获取乐观读锁后，还需要对结果进行校验  
13.4.3 StampedLock的特点  
● 所有获取锁的方法，都返回一个邮戳，stamp为零表示失败，其余都表示成功  
● 所有释放锁的方法，都需要一个邮戳，这个stamp必须是和成功获取锁时得到的stamp一致  
● StampedLock是不可重入的，危险（如果一个线程已经持有了写锁，在去获取写锁的话会造成死锁）

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

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

13.4.5 乐观读模式Code演示  
● 传统的读写锁模式----读的时候写锁不能获取

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	写线程结束修改
     */

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

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
     */

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

[9cff7ac129c14e67bd2b502e62ae4b8b.png_pic_center]: https://img-blog.csdnimg.cn/9cff7ac129c14e67bd2b502e62ae4b8b.png#pic_center