Java内置锁：深度解析StampedLock并发类

内容摘要

StampedLock类是一种高性能的读写锁，它通过引入乐观读和写锁的优化机制，提高了多线程环境下的并发性能，他支持三种访问模式：悲观读、写和乐观读，可以根据不同的业务场景选择适合的锁策略，相比传统的读写锁，StampedLock能够更好地利用多核处理器的优势，减少线程间的竞争和阻塞，从而提升系统的吞吐量和响应速度。

官方文档地址：https://docx.iamqiang.com/jdk11/api/java.base/java/util/concurrent/locks/StampedLock.html

使用场景

StampedLock是一个优化的读写锁，它在多核处理器上提供了比ReentrantReadWriteLock更高的性能，与传统的读写锁不同，StampedLock支持三种访问模式：读、写和乐观读，并且这三种模式都可以相互转换。

假设有一个在线书店系统，其中一个关键功能是书籍的库存更新，每当用户购买书籍时，系统需要从库存中减去相应的数量，同时，为了提供良好的用户体验，系统还需要实时显示每本书的当前库存量，以供其他用户参考。在这个场景中，库存更新操作（写操作）和库存查询操作（读操作）是频繁发生的，而且，多个用户可能同时查询同一本书的库存，但同一时间只有一个用户能够更新库存。

可以使用StampedLock解决这个问题，如下操作：

1. 写操作（库存更新）：当一个用户下单购买书籍时，系统会获取一个写锁，确保在更新库存的过程中，其他用户不能同时进行读或写操作，这就像是在书店里，当售货员正在为一位顾客取书并更新库存时，其他顾客需要稍等片刻，直到售货员完成操作。
2. 读操作（库存查询）：多个用户可以同时查询同一本书的库存，而不会相互干扰，这时，系统会为每个查询请求获取一个读锁，这就像是在书店里，多位顾客可以同时查看书架上的书籍，了解库存情况。
3. 乐观读：StampedLock还提供了一种乐观读的模式，它允许在不阻塞其他写操作的情况下进行读操作，如果读操作期间发生了写操作，乐观读可以通过检查一个“戳记”（stamp）来发现数据的不一致性，并重新执行读操作，这就像是一位顾客在查看库存时，突然意识到售货员正在为另一位顾客取书并更新库存，这时他可以稍等片刻，然后再次查看最新的库存信息。

代码案例

StampedLock 类中的 asReadLock() 方法用于获取一个 Lock 视图，该视图具有与 StampedLock 的读锁相同的锁定含义，可以使用返回的 Lock 对象进行读锁定，就像使用 ReentrantReadWriteLock 的读锁一样，但是，通常建议使用 StampedLock 的其他方法来获取读锁，因为它们可以提供更精细的控制和更高的性能。

下面是一个简单的例子，演示了使用 StampedLock 类的基本使用方法，这个例子创建了一个简单的计数器类，该类使用 StampedLock 来同步对内部计数器的访问，如下代码：

import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.StampedLock;  

/**
 * @创建人 程序员古德 <br>
 * @创建时间 2024/1/18 12:00 <br>
 * @修改人 暂无 <br>
 * @修改时间 暂无 <br>
 * @版本历史 暂无 <br>
 */

public class Counter {  
    private int count;  
    private final StampedLock stampedLock = new StampedLock();  
  
    // 使用 StampedLock 的 asReadLock() 方法获取读锁  
    public void readCountWithLock() {  
        Lock readLock = stampedLock.asReadLock();  
        readLock.lock(); // 获取读锁  
        try {  
            System.out.println("Current count: " + count);  
        } finally {  
            readLock.unlock(); // 释放读锁  
        }  
    }  
  
    // 使用 StampedLock 的普通读方法  
    public int readCountWithStamp() {  
        long stamp = stampedLock.tryOptimisticRead(); // 尝试乐观读  
        int currentCount = count;  
  
        // 检查乐观读后数据是否被修改  
        if (!stampedLock.validate(stamp)) {  
            // 如果数据被修改，获取读锁重新读取  
            stamp = stampedLock.readLock();  
            try {  
                currentCount = count;  
            } finally {  
                stampedLock.unlockRead(stamp);  
            }  
        }  
        return currentCount;  
    }  
  
    // 增加计数器的值  
    public void incrementCount() {  
        long stamp = stampedLock.writeLock(); // 获取写锁  
        try {  
            count++;  
        } finally {  
            stampedLock.unlockWrite(stamp); // 释放写锁  
        }  
    }  
  
    public static void main(String[] args) throws InterruptedException {  
        Counter counter = new Counter();  
  
        // 启动一个线程来增加计数器的值  
        Thread incrementThread = new Thread(() -> {  
            for (int i = 0; i < 5; i++) {  
                counter.incrementCount();  
                try {  
                    Thread.sleep(100); // 休眠以模拟工作负载  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        });  
  
        // 启动一个线程来读取计数器的值（使用 Lock）  
        Thread readThreadWithLock = new Thread(() -> {  
            for (int i = 0; i < 5; i++) {  
                counter.readCountWithLock();  
                try {  
                    Thread.sleep(100); // 休眠以模拟工作负载  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        });  
  
        // 启动一个线程来读取计数器的值（使用 stamp）  
        Thread readThreadWithStamp = new Thread(() -> {  
            for (int i = 0; i < 5; i++) {  
                System.out.println("Current count (stamp): " + counter.readCountWithStamp());  
                try {  
                    Thread.sleep(100); // 休眠以模拟工作负载  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        });  
  
        // 启动所有线程  
        incrementThread.start();  
        readThreadWithLock.start();  
        readThreadWithStamp.start();  
  
        // 等待所有线程完成  
        incrementThread.join();  
        readThreadWithLock.join();  
        readThreadWithStamp.join();  
    }  
}

在上面代码中，Counter 类有一个 count 变量，它可以通过 incrementCount 方法来增加，读取计数器值的方法有两种：readCountWithLock 使用 asReadLock() 方法返回的 Lock 对象进行同步，而 readCountWithStamp 则使用 StampedLock 的乐观读和读锁功能。在 main 方法中，启动了三个线程，一个用于增加计数器的值，另外两个用于读取计数器的值（一个使用 Lock，另一个使用 stamp）。

asReadLock() 方法提供了普通 Lock 的方式，但通常建议直接使用 StampedLock 的其他方法（如 tryOptimisticRead、readLock、unlockRead 等），因为它们提供了更高级别的并发控制和性能优化。

核心总结

StampedLock类总结

StampedLock提供了一种高效的线程同步方式，与传统的读写锁相比，如：ReentrantReadWriteLock，StampedLock则在某些方面展现出了其独特的优势，如下分析：

优点：

1. 高效的读性能：StampedLock在读操作上的性能尤为出色，它允许多个线程同时读取共享资源，而无需像ReentrantReadWriteLock那样在读线程之间保持互斥，这在读操作远多于写操作的场景中，能够显著提升系统的整体吞吐量。
2. 乐观读策略：StampedLock引入了乐观读的概念，在进行读取操作前，线程可以尝试不获取锁直接读取数据，然后通过验证一个“戳记”（stamp）来确认数据在读取过程中是否被修改，这种策略在数据冲突较少的场景下能够减少不必要的锁竞争，从而提高性能。
3. 轻量级设计：与ReentrantReadWriteLock相比，StampedLock的设计更为轻量级，没有与Condition相关的复杂机制，这使得它在简单的同步场景中更为高效。

缺点：

1. 不支持重入性：StampedLock不是重入锁，这意味着同一个线程不能重复获取同一个锁，在处理递归逻辑或需要在持有锁的情况下，可能会带来额外的复杂性。
2. 缺乏条件变量：与ReentrantLock和ReentrantReadWriteLock不同，StampedLock没有提供与条件变量（Condition）相关的功能，使得它在需要等待/通知机制的复杂同步场景中不够灵活。

使用建议：

• 如果读操作远多于写操作，且不需要重入锁或条件变量支持，那么StampedLock可能是一个不错的选择。
• 要特别注意正确地管理锁的生命周期和戳记的验证过程，以避免死锁和其他同步问题。
• 对于复杂的同步场景或需要等待/通知机制的情况，ReentrantLock或ReentrantReadWriteLock会具有一定的优势。

StampedLock和ReentrantReadWriteLock有什么区别？

StampedLock和ReentrantReadWriteLock都是Java中用于同步的机制，它们允许多个线程同时读取共享资源，但在写入时要求独占访问，尽管它们的目的相似，但在设计、性能和适用场景上存在一些关键区别：

在设计上：

1. StampedLock: 是一个非重入锁，意味着同一个线程不能重复获取同一个锁，无论是读锁还是写锁，StampedLock提供了三种访问模式：读锁、写锁和乐观读，乐观读是一种非阻塞的读取策略，它允许线程在不阻塞的情况下尝试读取数据，然后通过验证一个“戳记”（stamp）来确认数据在读取过程中没有被修改。
2. ReentrantReadWriteLock: 是一个重入锁，允许同一个线程多次获取同一个锁，这在递归算法或需要锁跨越多个方法调用时非常有用，它只提供两种访问模式：读锁和写锁。

在性能上：

1. StampedLock: 通常在读操作远多于写操作的场景中提供更好的性能，由于StampedLock支持乐观读，这可以避免不必要的上下文切换和线程阻塞，从而提高吞吐量，此外，StampedLock在读锁之间没有互斥，允许多个线程同时持有读锁。
2. ReentrantReadWriteLock: 在读锁和写锁之间的切换上可能不如StampedLock高效，尤其是在高并发环境下，然而，在需要重入锁的场景中，它是更具有优势。

在适用场景上：

1. StampedLock: 适用于读多写少的高并发场景，且当线程不需要在持有锁的情况下调用其他可能也需要该锁的方法时，由于它的非重入性，使用StampedLock需要更仔细地管理锁的生命周期，以避免死锁。
2. ReentrantReadWriteLock: 更适用于需要锁的可重入性的场景，如递归算法或需要在持有锁的情况下调用其他可能也需要该锁的方法的情况，此外，在写操作相对频繁或读/写操作分布更均匀的场景中，ReentrantReadWriteLock更具有优势。

其他对比：

1. 公平性: ReentrantReadWriteLock允许在构造函数中指定公平性策略（即线程获取锁的顺序），而StampedLock不支持公平性设置。
2. 条件变量: ReentrantReadWriteLock与ReentrantLock类似，可以与Condition对象一起使用，以支持等待/通知机制，而StampedLock不提供条件变量，因此不适用于需要等待某个条件的场景。

END！