⚡️StampedLock邮戳锁⚡️

冷不防 2022-09-13 04:30 195阅读 0赞

### 文章目录 ###

*   *  StampedLock是什么
     *  由锁饥饿问题引出StampedLock
     *   *  如何缓解锁饥饿问题？
         *   *  1 使用“公平”策略可以一定程度上缓解这个问题
             *  2 StampedLock类的乐观读锁闪亮登场 是对读写锁的补充
     *  StampedLock的特点
     *   *  乐观读模式code演示
     *  StampedLock的缺点

## StampedLock是什么 ##

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

邮戳锁也叫票据锁

有一个stamp变量（戳记，long类型）

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

## 由锁饥饿问题引出StampedLock ##

![image-20210913222746190][]

ReentrantReadWriteLock允许多个线程同时读,但是只允许一个线程写,在线程获取到写锁的时候,其他写操作和读操作都会处于阻塞状态,读锁和写锁也是互斥的,所以在读的时候是不允许写的,读写锁比传统的synchronized速度要快很多,原因就是在于ReentrantReadWriteLock支持读并发

锁饥饿问题：

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

### 如何缓解锁饥饿问题？ ###

#### 1 使用“公平”策略可以一定程度上缓解这个问题 ####

new ReentrantReadWriteLock(true);

但是“公平”策略是以牺牲系统吞吐量为代价的

#### 2 StampedLock类的乐观读锁闪亮登场 是对读写锁的补充 ####

ReentrantReadWriteLock的读锁被占用的时候,其他线程尝试获取写锁的时候会被阻塞。

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

StampedLock是为了进一步优化读性能，它的特点是在使用读锁、写锁时都必须配合【戳】使用

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4pEjOnxo-1632747263024)(E:\\笔记\\图片\\image\\09-2StampedLock邮戳锁.assets\\202109271859552.png)\]][img-4pEjOnxo-1632747263024_E_image_09-2StampedLock_.assets_202109271859552.png]

加解读锁

long stamp = lock.readLock();
    lock.unlockRead(stamp);

加解写锁

long stamp = lock.writeLock();
    lock.unlockWrite(stamp);

**乐观读**，StampedLock 支持 tryOptimisticRead() 方法（乐观读），读取完毕后需要做一次 戳校验 ，如果校验通  
过，表示这期间确实没有写操作，数据可以安全使用，如果校验没通过，需要重新获取读锁，保证数据安全。

//乐观读
    long stamp = lock.tryOptimisticRead();
    // 验戳失败 
    if(!lock.validate(stamp)){ 
    // 锁升级 为悲观读readLock
    }

## StampedLock的特点 ##

所有获取锁的方法，都返回一个邮戳（Stamp），Stamp为零表示获取失败，其余都表示成功；

所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致；

StampedLock是**不可重入的**，危险(如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁)

StampedLock有三种访问模式

①Reading（读模式）：功能和ReentrantReadWriteLock的读锁类似

②Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似

③Optimistic reading（乐观读模式）：无锁机制，类似于数据库中的乐观锁，  
支持读写并发，很乐观认为读取时没人修改，假如被修改再实现升级为悲观读模式

### 乐观读模式code演示 ###

package com.dongguo.readwrite;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.StampedLock;
    
    /** * @author Dongguo * @date 2021/9/9 0009-22:58 * @description: */
    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;
            }catch (Exception e){ 
                e.printStackTrace();
            }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 block,4 seconds continue...");
            //暂停几秒钟线程
            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("写线程没有修改值，因为 stampedLock.readLock()读的时候，不可以写，读写互斥");
            }catch (Exception e){ 
                e.printStackTrace();
            }finally { 
                stampedLock.unlockRead(stamp);
            }
        }
    
        //乐观读
        public void tryOptimisticRead()
        { 
            long stamp = stampedLock.tryOptimisticRead();
            int result = number;
            //间隔4秒钟，我们很乐观的认为没有其他线程修改过number值，实际靠判断。
            System.out.println("4秒前stampedLock.validate值(true无修改，false有修改)"+"\t"+stampedLock.validate(stamp));
            for (int i = 1; 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);
                }catch (Exception e){ 
                    e.printStackTrace();
                }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();
                //resource.tryOptimisticRead();
            },"readThread").start();
    
            // 2秒钟时乐观读失败，6秒钟乐观读取成功resource.tryOptimisticRead();，修改切换演示
            //try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); }
    
            new Thread(() -> { 
                resource.write();
            },"writeThread").start();
        }
    }

读的过程中也允许获取写锁介入

## StampedLock的缺点 ##

StampedLock **不支持重入**，没有Re开头

StampedLock 的悲观读锁和写锁都**不支持条件变量（Condition）**，这个也需要注意。

**使用 StampedLock一定不要调用中断操作**，即不要调用interrupt() 方法

如果需要支持中断功能，一定使用可中断的悲观读锁 readLockInterruptibly()和写锁writeLockInterruptibly()

[image-20210913222746190]: /images/20220828/f3a67497b4c444bfa36641ba77799db3.png
[img-4pEjOnxo-1632747263024_E_image_09-2StampedLock_.assets_202109271859552.png]: /images/20220828/cedc2e2518fb4b80a79a1028aa5750b3.png