StampedLock类的简介

StampedLock类，在JDK1.8时引入，是对读写锁ReentrantReadWriteLock的增强，该类提供了一些功能，优化了读锁、写锁的访问，同时使读写锁之间可以互相转换，更细粒度控制并发。它的特点是在使用读锁、写锁时都必须配合【戳】使用，如：
image.png
这个戳通常会配合该类的tryOptimisticRead方法使用，tryOptimisticRead方式采用的是乐观读的思想。在ReentrantReadWriteLock中，当读锁被使用时，如果有线程尝试获取写锁，该写线程会阻塞。但是，在Optimistic reading中，即使读线程获取到了读锁，写线程尝试获取写锁也不会阻塞，这相当于对读模式的优化，但是可能会导致数据不一致的问题。所以，当使用Optimistic reading获取到读锁时，必须对获取结果使用戳进行校验。

StampedLock的特点

  • StampedLock 是从 JDK1.8 开始提供，它的性能比 ReadWriteLock 好
  • StampedLock 支持：乐观读锁、悲观读锁、写锁
  • StampedLock 不支持重入
  • StampedLock 支持锁的降级和升级 （即乐观读锁升级为写锁）

  • StampedLock 无论写锁还是读锁，都不支持Conditon等待

    StampedLock使用示例

    1. @Slf4j(topic = "c.DataContainerStamped")
    2. public class DataContainerStamped {
    3.   private int data;
    4.   private final StampedLock lock = new StampedLock();
    6.   public DataContainerStamped(int data) {
    7.       this.data = data;
    8.   }
    10.   public void read(int readTime) throws InterruptedException {
    11.       long stamp = lock.tryOptimisticRead();
    12.       log.debug("optimistic read locking...{}", stamp);
    13.       Thread.sleep(readTime * 1000L);
    14.       //validate方法用于验戳，即验证数据是否被修改
    15.       if (lock.validate(stamp)) {
    16.           log.debug("read finish...{}, data:{}", stamp, data);
    17.           return;
    18.       }
    19.       // 锁升级 - 读锁（悲观读锁）
    20.       log.debug("updating to read lock... {}", stamp);
    21.       try {
    22.           stamp = lock.readLock();
    23.           log.debug("read lock {}", stamp);
    24.           Thread.sleep(readTime * 1000L);
    25.           log.debug("read finish...{}, data:{}", stamp, data);
    26.       } finally {
    27.           log.debug("read unlock {}", stamp);
    28.           lock.unlockRead(stamp);
    29.       }
    30.   }
    32.   public void write(int newData) throws InterruptedException {
    33.       long stamp = lock.writeLock();
    34.       log.debug("write lock {}", stamp);
    35.       try {
    36.           Thread.sleep(2 * 1000L);
    37.           this.data = newData;
    38.       } finally {
    39.           log.debug("write unlock {}", stamp);
    40.           lock.unlockWrite(stamp);
    41.       }
    42.   }
    43. }

    测试代码：

    1. public static void main(String[] args) throws InterruptedException {
    2.       DataContainerStamped dataContainer = new DataContainerStamped(1);
    3.       new Thread(() -> {
    4.           try {
    5.               dataContainer.read(1);
    6.           } catch (InterruptedException e) {
    7.               e.printStackTrace();
    8.           }
    9.       }, "t1").start();
    10.       new Thread(() -> {
    11.           try {
    12.               dataContainer.write(2);
    13.           } catch (InterruptedException e) {
    14.               e.printStackTrace();
    15.           }
    16.       }, "t2").start();
    17.   }

    测试结果：
    image.png
    可以看到在“01:28:24”，t1获取乐观读锁，随后t2获取写锁，t2并没有被阻塞，因此验证了可以从乐观读锁升级为写锁的特点。StampedLock 相比于读写锁有很多优点，但是有两个比较大的缺点：

    • StampedLock 不支持条件变量
    • StampedLock 不支持可重入