高性能读写锁StampedLock

ReentrantReadWriteLock 的性能已经很好了但是他底层还是需要进行一系列的cas操作去加锁；
StampedLock如果是读锁上锁是没有这种cas操作的性能比ReentrantReadWriteLock 更好
也称为乐观读锁；即读获取锁的时候 是不加锁 直接返回一个值；然后执行临界区的时候去验证这个值是
否有被人修改（写操作加锁）
如果没有被人修改则直接执行临界区的代码；如果被人修改了则需要升级为读写锁
(ReentrantReadWriteLock--->readLock);
基本语法：
//获取戳 不存在锁
long stamp = lock.tryOptimisticRead();
//验证戳
if(lock.validate(stamp)){
//成立则执行临界区的代码
//返回
} /
/如果没有返回则表示被人修改了 需要升级成为readLock
lock.readLock();
 

代码示例
 

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.StampedLock;
/**
 * 一个数据容器
 * 不支持重入
 * 不支持条件*/
@Slf4j(topic = "test")
public class DataContainer {
    int i;
    long stampw=0l;
    public void setI(int i) {
        this.i = i;
    }
    private final StampedLock lock = new StampedLock();
    //首先 加 StampedLock
    @SneakyThrows
    public int read() {
        //尝试一次乐观读
        long stamp = lock.tryOptimisticRead();
        log.info("StampedLock 读锁拿到的戳{}", stamp);
        //1s之后验戳
        TimeUnit.SECONDS.sleep(1);
        //验戳
        if (lock.validate(stamp)) {
            log.info("StampedLock 验证完毕stamp{}, data.i:{}", stamp, i);
            return i;
        }
        //一定验证失败
        log.info("验证失败 被写线程给改变了{}", stampw);
        try {
            //锁的升级 也会改戳
            stamp = lock.readLock();
            log.info("升级之后的加锁成功 {}", stamp);
            TimeUnit.SECONDS.sleep(1);
            log.info("升级读锁完毕{}, data.i:{}", stamp, i);
            return i;
        } finally {
            log.info("升级锁解锁 {}", stamp);
            lock.unlockRead(stamp);
        }
    }
    @SneakyThrows
    public void write(int i) {
        //cas 加锁
        stampw = lock.writeLock();
        log.info("写锁加锁成功 {}", stampw);
        try {
            TimeUnit.SECONDS.sleep(5);
            this.i = i;
        } finally {
            log.info("写锁解锁 {},data.i{}", stampw,i);
            lock.unlockWrite(stampw);
        }
    }
}

import java.util.concurrent.TimeUnit;
public class StampedLockTest {
    public static void main(String[] args) throws InterruptedException {
        //实例化数据容器
        DataContainer dataContainer = new DataContainer();
        //给了一个初始值 不算写 构造方法赋值
        dataContainer.setI(1);
        //读取
        new Thread(() -> {
            dataContainer.read();
        }, "t1").start();
        // new Thread(() -> {
        // dataContainer.read();
        // }, "t2").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            dataContainer.write(9);
        }, "t2").start();
    }
}

 

那么StampedLock的性能这么好能否替代ReentrantReadWriteLock ？
1、他不支持重入
2、不支持条件队列
3、存在一定的并发问题