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

本文主要是介绍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;}}
  }

这篇关于Java 多线程之 StampedLock（读写锁/乐观读锁/共享锁/排他锁）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---