Java的StampedLock：如何通过validate()方法实现乐观读锁的有效性校验 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，我们开始今天的讲座。今天的主题是Java的StampedLock，特别是如何通过validate()方法来实现乐观读锁的有效性校验。

StampedLock：比ReadWriteLock更灵活的读写锁

在并发编程中，读写锁（ReadWriteLock）是一种常见的同步工具，它允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。Java的java.util.concurrent.locks.ReadWriteLock接口提供了这种机制。然而，ReadWriteLock在某些场景下可能不够灵活，例如，当读操作非常频繁，且写入操作相对较少时，ReadWriteLock可能会导致不必要的锁竞争。

为了解决这个问题，Java 8引入了StampedLock。StampedLock提供了一种更加灵活的读写锁机制，它基于“邮戳” (stamp) 的概念，允许线程尝试乐观地读取共享资源，而无需持有任何锁。如果读取过程中没有发生写入操作，则读取操作成功；否则，线程可以升级到读锁或写锁。

StampedLock相比ReadWriteLock的主要优点在于：

乐观读： 允许线程在没有锁的情况下读取共享资源，从而减少锁竞争。
锁升级： 允许线程将乐观读锁升级到读锁或写锁，从而避免重复获取锁。
锁降级： 允许线程将写锁降级到读锁，从而提高并发性能。

StampedLock的核心方法

StampedLock提供了一系列方法用于获取和释放锁。以下是一些常用的方法：

方法名	描述
`readLock()`	获取一个独占的读锁。如果当前有写锁被持有，则当前线程会被阻塞，直到写锁被释放。
`tryReadLock()`	尝试获取一个独占的读锁，如果当前没有写锁被持有，则立即返回一个非零的stamp值，表示成功获取了读锁；否则，立即返回零，表示获取读锁失败。
`writeLock()`	获取一个独占的写锁。如果当前有读锁或写锁被持有，则当前线程会被阻塞，直到所有读锁和写锁都被释放。
`tryWriteLock()`	尝试获取一个独占的写锁，如果当前没有读锁或写锁被持有，则立即返回一个非零的stamp值，表示成功获取了写锁；否则，立即返回零，表示获取写锁失败。
`tryOptimisticRead()`	尝试获取一个乐观读锁，立即返回一个非零的stamp值。即使此时有写锁被持有，也会返回一个非零的stamp值。乐观读锁并不阻止写操作，因此需要通过`validate()`方法来验证读取的数据是否有效。
`validate(long stamp)`	验证乐观读锁的stamp值是否有效。如果自获取stamp值以来，没有发生写操作，则返回true；否则，返回false。
`unlockRead(long stamp)`	释放一个读锁。需要传入获取读锁时返回的stamp值。
`unlockWrite(long stamp)`	释放一个写锁。需要传入获取写锁时返回的stamp值。
`unlock(long stamp)`	释放一个读锁或者写锁。需要传入获取锁时返回的stamp值。使用时需要注意，传入的stamp值必须是有效的读锁或写锁的stamp值，否则会抛出`IllegalMonitorStateException`异常。一般不推荐使用这个方法，而推荐使用`unlockRead()`和`unlockWrite()`方法，因为它们可以更清晰地表达释放的是哪种类型的锁。
`tryConvertToWriteLock(long stamp)`	尝试将一个读锁转换为写锁。如果当前没有其他线程持有锁，则立即返回一个新的stamp值，表示转换成功；否则，立即返回零，表示转换失败。这个方法可以用于在读取数据后，如果需要修改数据，则尝试将读锁转换为写锁，而无需释放读锁再重新获取写锁。
`tryConvertToReadLock(long stamp)`	尝试将一个写锁转换为读锁。如果当前没有其他线程持有写锁，则立即返回一个新的stamp值，表示转换成功；否则，立即返回零，表示转换失败。这个方法可以用于在修改数据后，如果需要继续读取数据，则尝试将写锁转换为读锁，从而允许其他线程并发读取数据。

乐观读锁的有效性校验：validate()方法

tryOptimisticRead()方法返回一个stamp值，这个值代表了乐观读锁的状态。但重要的是，tryOptimisticRead()并不阻止写操作，这意味着在乐观读锁持有期间，其他线程仍然可以获取写锁并修改共享资源。 因此，我们需要使用validate(long stamp)方法来验证在读取共享资源期间，是否有写操作发生。

validate(long stamp)方法的工作原理是检查自获取stamp值以来，是否有其他线程获取了写锁。如果期间没有发生写操作，则validate()返回true，表示读取的数据有效；否则，返回false，表示读取的数据可能已经过时，需要重新读取。

乐观读锁的使用步骤

使用乐观读锁的一般步骤如下：

使用tryOptimisticRead()方法获取一个乐观读锁的stamp值。
读取共享资源。
使用validate(long stamp)方法验证乐观读锁的有效性。
- 如果validate()返回true，则读取的数据有效，可以继续使用。
- 如果validate()返回false，则读取的数据可能已经过时，需要升级到读锁或写锁，并重新读取数据。

代码示例

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {

    private final StampedLock lock = new StampedLock();
    private int x = 0;
    private int y = 0;

    public void moveIfAtOrigin(int newX, int newY) {
        // 乐观读
        long stamp = lock.tryOptimisticRead();
        try {
            // 读操作
            int currentX = x;
            int currentY = y;
            if (currentX == 0 && currentY == 0) {
                // 验证乐观读是否有效
                if (!lock.validate(stamp)) {
                    // 乐观读失效，升级到写锁
                    stamp = lock.writeLock();
                    try {
                        // 重新读取共享变量
                        currentX = x;
                        currentY = y;
                        if (currentX == 0 && currentY == 0) {
                            x = newX;
                            y = newY;
                        }
                    } finally {
                        lock.unlockWrite(stamp);
                    }
                } else {
                    // 乐观读有效，不需要升级锁
                }
            }
        } finally {
            // 释放乐观读锁（如果需要）
            // 在乐观读有效的情况下，不需要显式释放锁
            // 因为乐观读本身并不持有锁
            // 如果升级到了写锁，则在写锁的finally块中释放
        }
    }

    public int distanceFormOrigin() {
        long stamp = lock.tryOptimisticRead();
        int currentX = x;
        int currentY = y;
        if (!lock.validate(stamp)){
            stamp = lock.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return (int) Math.sqrt(currentX * currentX + currentY * currentY);
    }

    public static void main(String[] args) throws InterruptedException {
        StampedLockExample example = new StampedLockExample();

        // 模拟多个线程并发访问
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            int index = i;
            threads[i] = new Thread(() -> {
                if (index % 2 == 0) {
                    // 偶数线程：尝试移动到新的位置
                    example.moveIfAtOrigin(index, index);
                } else {
                    // 奇数线程：计算距离
                    System.out.println("Distance: " + example.distanceFormOrigin());
                }
            });
            threads[i].start();
        }

        // 等待所有线程执行完成
        for (Thread thread : threads) {
            thread.join();
        }

        System.out.println("Final x: " + example.x + ", y: " + example.y);
    }
}

在这个例子中，moveIfAtOrigin()方法首先尝试获取一个乐观读锁。如果x和y都为0，则验证乐观读锁的有效性。如果乐观读锁失效，则升级到写锁，并重新读取x和y的值，然后再更新它们。distanceFormOrigin()方法也使用了类似的逻辑，先尝试乐观读，如果失效则升级为读锁。

validate()方法的性能考量

validate()方法本身是一个轻量级的操作，它只是简单地检查锁的状态。因此，在乐观读锁有效的情况下，使用validate()方法进行验证并不会带来显著的性能开销。但是，如果乐观读锁经常失效，导致需要升级到读锁或写锁，则可能会降低并发性能。

使用StampedLock的注意事项

避免长时间持有锁： 无论是读锁还是写锁，都应该尽量缩短持有时间，以减少锁竞争。
注意死锁： 在使用StampedLock时，需要特别注意死锁的发生。例如，如果一个线程持有读锁，并尝试升级到写锁，而另一个线程持有写锁，并尝试降级到读锁，则可能会发生死锁。
异常处理： 在try块中获取锁，并在finally块中释放锁，以确保锁总是被释放，即使发生异常。
unlock(long stamp)谨慎使用： 如前所述，不推荐使用unlock(long stamp)，应该使用unlockRead(long stamp)和unlockWrite(long stamp)。

StampedLock与ReadWriteLock的比较

发表回复 取消回复

发表回复取消回复