Java 多线程之 StampedLock（读写锁/乐观读锁/共享锁/排他锁）

一、概述

• StampedLock是Java 8引入的一种读写锁的实现，它提供了一种乐观的读锁（Optimistic Read Lock）和悲观的读锁（Pessimistic Read Lock），和写锁（Write Lock），以及对读-写冲突的解决方案。StampedLock的设计目标是在读多写少的场景下提供更高的并发性能。与传统的读写锁相比，StampedLock更加灵活和高效。

• StampedLock 的主要功能如下：

  • 乐观读取（Optimistic Reading）：通过调用 tryOptimisticRead() 方法获取一个乐观读锁的标记（stamp），该标记可以用于后续的读操作。乐观读锁不会阻塞写操作，即使其他线程在你获取锁之后进行了写操作，你的读操作仍然可以继续进行。但需要注意的是，乐观读锁并不能保证数据的一致性，因此在使用乐观读锁后，需要进一步验证数据的有效性。

  • 悲观读锁（Pessimistic Read Lock）：通过调用 readLock() 方法获取一个悲观读锁，该锁会阻塞其他线程的写操作，保证了数据的一致性。在获取悲观读锁后，可以执行读操作，并且允许其他线程同时获取乐观读锁。

  • 写锁（Write Lock）：通过调用 writeLock() 方法获取一个写锁，该锁会阻塞其他线程的读和写操作，保证了数据的一致性。在获取写锁后，可以执行写操作，期间不允许其他线程获取读锁或写锁。

  • 写锁和读锁的分离：在传统的读写锁中，写锁的获取会阻塞其他线程的读取和写入操作。而StampedLock将读锁和写锁分离，使得读锁之间不会互相阻塞，提高了并发读取的效率。

  • 读写冲突解决：StampedLock使用类似于版本号的机制（称为"stamp"）来解决读写冲突。每次获取读锁或写锁时会返回一个stamp，可以用来检查共享数据是否被其他线程修改过。

  • 支持条件等待：StampedLock提供了 Condition 接口的条件等待方法，可以使用条件等待来实现更复杂的线程协调。

• 前面讲过 ReentrantReadWriteLock 使用方法，与之相比，StampedLock 在某些情况下可以提供更高的性能，但并不是在所有情况下都表现更好。StampedLock 的优势主要表现在支持乐观读取机制和条件等待。所以在写操作频繁而读操作较少和存在大量的锁竞争的情况下，直接使用悲观读锁，性能跟ReentrantReadWriteLock是相差不大的。

• 注意：乐观读锁其实没有加锁，就是尝试去读，只要数据没有发生变化，读取的值就有效；否则重新再读一次。乐观读锁就是按这个逻辑执行。

二、使用方法

• 使用StampedLock的基本步骤如下：

  1. 创建StampedLock对象：通过 StampedLock lock = new StampedLock(); 语句创建StampedLock对象。

  2. 读取操作：使用 lock.tryOptimisticRead() 方法获取一个乐观读锁的 stamp，并读取共享数据。在读取过程中，需要使用lock.validate(stamp) 方法验证读取期间共享数据是否被修改过，如果没有修改再使用悲观读锁，而不是直接使用悲观读锁。

  3. 写入操作：使用 lock.writeLock() 方法获取写锁，并进行写入操作。

  4. 读写锁的转换：可以使用 lock.tryConvertToReadLock(stamp) 或 lock.tryConvertToWriteLock(stamp) 方法将乐观读锁转换为悲观读锁或写锁。这样可以避免释放乐观读锁后再重新获取悲观读锁或写锁。

  import java.util.concurrent.locks.StampedLock;
  
  public class StampedLockExample {
      private Object SharedData;
      private final StampedLock lock = new StampedLock();
  
      public void write(Object obj) {
          //获取写锁
          long stamp = lock.writeLock();
          try {
              // 执行写业务逻辑，如下
              SharedData = obj;
          } finally {
              // 释放写锁
              lock.unlockWrite(stamp);
          }
      }
  
      // 完全使用乐观读锁
      public Object read1() {
          while(true){
              Object result = null;
              
              // 获取乐观读锁
              long stamp = lock.tryOptimisticRead(); 
              // 执行读业务逻辑，如下
              result = SharedData;
              // 验证共享数据是否被修改，如果没有被修改过，则直接返回。否则重新读
              if (lock.validate(stamp)) {
  		      return result;
              }
          }
      }
      
      // 使用乐观读锁 + 非观读锁
      public Object read2() {
          Object result = null;
          
          // 获取乐观读锁
          long stamp = lock.tryOptimisticRead(); 
          // 执行读业务逻辑（这里先读一次），如下
          result = SharedData;
          
          // 验证共享数据是否被修改
          if (lock.validate(stamp)) {
              // 如果共享数据没有被修改过，则直接使用
              return result;
          }
          
          // 获取悲观读锁
          stamp = lock.readLock();
          try {
              // 执行读业务逻辑，重新读
              result = SharedData;
          } finally {
              // 释放写锁
              lock.unlockRead(stamp);
          }
          
          return result;
      }
  }
  

三、测试示例

• 在下面示例中，创建了一个 StampedLockExample 类，他包括一个写方法，一个乐观读方法和一个乐观结合悲观的读方法。在 main 方法使用1个线程调用写方法，5个线程调用乐观锁读方法，5个线程调用乐观锁加悲观乐的读方法。两个读方法在实际应用中任选一种即可。

  使用StampedLock时需要注意以下几点：

  • 使用乐观读取时，需要在读取操作的开始和结束处进行验证，以确保读取期间共享数据没有被修改。
  • 第一种读取方法是：验证后如果修改，则重新读一次再验证，直到没有被修改则返回
  • 第二种读取方法是：在使用乐观读取之后，如果发现共享数据被修改，尝试转换为悲观读锁或写锁，以避免重新获取锁。
  • 写锁的获取是独占的，会阻塞其他读取和写入操作。因此，在使用写锁时需要注意避免写锁的持有时间过长，避免对性能造成影响。

  package top.yiqifu.study.p004_thread;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.concurrent.locks.StampedLock;
  
  public class Test081_StampedLock {
  
      public static void main(String[] args) {
          StampedLockExample stampedLockExample = new StampedLockExample();
  
          List<Thread> threads = new ArrayList();
          for(int i = 1; i<= 1; i++){
              Thread t = new Thread(()->{
                  for(int j=0; j< 100000; j++){
                      try {
                          String text = Thread.currentThread().getName()+" 共享数据 "+ j;
                          stampedLockExample.write(text);
                          System.out.println(text);
  
                          Thread.sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              });
              t.setName("写线程"+i);
              threads.add(t);
          }
          for(int i = 1; i<= 5; i++){
              Thread t = new Thread(()->{
                  for(int j=0; j< 100000; j++){
                      try {
                          String result = stampedLockExample.read1();
                          System.out.println(Thread.currentThread().getName()+" 读取 "+result);
                          Thread.sleep(100);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              });
              t.setName("乐观读线程"+i);
              threads.add(t);
          }
          for(int i = 1; i<= 5; i++){
              Thread t = new Thread(()->{
                  for(int j=0; j< 100000; j++){
                      try {
                          String result = stampedLockExample.read1();
                          System.out.println(Thread.currentThread().getName()+" 读取 "+result);
                          Thread.sleep(100);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              });
              t.setName("乐+悲读线程"+i);
              threads.add(t);
          }
  
          for(Thread t : threads){
              t.start();
          }
  
          for(Thread t : threads){
              try {
                  t.join();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  
  
  
      public static class StampedLockExample {
          private String SharedData;
          private final StampedLock lock = new StampedLock();
  
          public void write(String text) {
              long stamp = lock.writeLock();
              try {
                  SharedData = text;
              } finally {
                  lock.unlockWrite(stamp);
              }
          }
  
          // 完全使用乐观读锁
          public String read1() {
              while(true){
                  String result = null;
  
                  long stamp = lock.tryOptimisticRead();
                  result = SharedData;
                  if (lock.validate(stamp)) {
                      return result;
                  }
              }
          }
  
          // 使用乐观读锁 + 非观读锁
          public String read2() {
              String result = null;
  
              long stamp = lock.tryOptimisticRead();
              result = SharedData;
              if (lock.validate(stamp)) {
                  return result;
              }
  
              stamp = lock.readLock();
              try {
                  result = SharedData;
              } finally {
                  lock.unlockRead(stamp);
              }
  
              return result;
          }
      }
  }