StampedLock(戳记锁)源码解读与使用

🏷️个人主页：牵着猫散步的鼠鼠 

🏷️系列专栏：Java源码解读-专栏

🏷️个人学习笔记，若有缺误，欢迎评论区指正 

1. 前言

我们在上一篇写ReentrantReadWriteLock读写锁的末尾留了一个小坑，那就是读写锁因为写锁的悲观性，会导致 “写饥饿”，这样一来会大大的降低读写效率，而今天我们就来将此坑填之！填坑工具为：StampedLock，一个素有Java锁王称号的同步类，也是在 java.util.concurrent.locks 包中。

这个类实际上很少见，面试的话应该不会问到的吧(应该大概可能)，不过内部实现逻辑值得学习

2. StampedLock 是什么？

StampedLock 是Java 8引入的一种新的锁机制，它是java.util.concurrent.locks包中的一个高级并发控制工具。StampedLock 设计用于提供三种模式的锁，分别是写锁、读锁和乐观读锁，并且旨在优化性能，尤其是在读多写少的场景下。

3. StampedLock的原理 

虽然StampedLock性能更好，但是！不可重入且不支持条件变量 Condition，且并没有直接实现Lock或者ReadWriteLock接口，而是与AQS类似的采用CLH(Craig, Landin, and Hagersten locks)作为底层实现。

在StampedLock 的底层提供了三种锁：

1. 写锁： 独占锁，一把锁只能被一个线程获得。当一个线程获取写锁后，其他请求读锁和写锁的线程必须等待。类似于 ReentrantReadWriteLock 的写锁，不过这里的写锁是不可重入的。
2. 读锁 （悲观读）：共享锁，没有线程获取写锁的情况下，多个线程可以同时持有读锁。如果己经有线程持有写锁，则其他线程请求获取该读锁会被阻塞。类似于 ReentrantReadWriteLock 的读锁，不过这里的读锁是不可重入的。
3. 乐观读 ：允许多个线程获取乐观读以及读锁。同时允许一个写线程获取写锁。

我们接下来看StampedLock内部的三个上锁方法

// 写锁
public long writeLock() {
    long s, next;  // bypass acquireWrite in fully unlocked case only
    return ((((s = state) & ABITS) == 0L &&
             U.compareAndSwapLong(this, STATE, s, next = s + WBIT)) ?
            next : acquireWrite(false, 0L));
}
// 读锁
public long readLock() {
    long s = state, next;  // bypass acquireRead on common uncontended case
    return ((whead == wtail && (s & ABITS) < RFULL &&
             U.compareAndSwapLong(this, STATE, s, next = s + RUNIT)) ?
            next : acquireRead(false, 0L));
}
// 乐观读
public long tryOptimisticRead() {
    long s;
    return (((s = state) & WBIT) == 0L) ? (s & SBITS) : 0L;
}

StampedLock 在获取锁的时候会返回一个 long 型的数据戳，该数据戳用于稍后的锁释放参数，如果返回的数据戳为 0 则表示锁获取失败。当前线程持有了锁再次获取锁还是会返回一个新的数据戳，这也是StampedLock不可重入的原因。此外，在官网给的示例中我们也看到了，StampedLock 还支持这3种锁的转换： 

long tryConvertToWriteLock(long stamp){}
long tryConvertToReadLock(long stamp){}
long tryConvertToOptimisticRead(long stamp){}

在源码中我们看到，无论哪种锁，在获取的时候都会返回一个long类型的时间戳，这其实就是StampedLock命名的由来(戳记锁)，而这个时间戳的第8位用来标识写锁，前 7 位（LG_READERS）来表示读锁，每获取一个悲观读锁，就加 1（RUNIT），每释放一个悲观读锁，就减 1。而悲观读锁最多只能装 128 个（7 位限制），很容易溢出，所以用一个 int 类型的变量来存储溢出的悲观读锁。

    // 用于计算state值的位常量
    private static final long RUNIT = 1L;
    private static final long WBIT  = 1L << LG_READERS;
    private static final long RBITS = WBIT - 1L;
    private static final long RFULL = RBITS - 1L;
    private static final long ABITS = RBITS | WBIT;
    private static final long SBITS = ~RBITS; // note overlap with ABITS

    // 初始化state值
    private static final long ORIGIN = WBIT << 1;

    // 同步状态state，第八位为写锁，前七位为读锁
    private transient volatile long state;
    // 写锁只占七位，最大值为128，使用readerOverflow来记录溢出的读锁
    private transient int readerOverflow;

4. StampedLock的使用

基于上面的StampedLock特性，我们写一个小demo来感受一下它的使用，需要注意的是在获取乐观锁时，如果有写锁改变数据时，为保证数据一致性，要切换为普通的读锁模式。

public class Test {

    private final StampedLock sl = new StampedLock();
    private int data = 0;

    public void write(int value) {
        long stamp = sl.writeLock();
        try {
            data = value;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    public int read() {
        long stamp = sl.tryOptimisticRead();
        int currentData = data;
        // 我们可以通过validate方法来校验戳记是否有效(没有人持有写锁)
        // 如果有写锁被占用，可能造成数据不一致，我们这里可以重新尝试读或者将乐观锁切换到读锁，        
        // 自己编写发生冲突时的具体逻辑
        if (!sl.validate(stamp)) {
            stamp = sl.readLock();
            try {
                currentData = data;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return currentData;
    }

    public static void main(String[] args) {
        Test test = new Test();

        Thread writer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                test.write(i);
                System.out.println("当前线程" + Thread.currentThread().getName() + ":Write: " + i);
            }
        });

        Thread reader = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                int value = test.read();
                System.out.println("当前线程" + Thread.currentThread().getName() + ":Read: " + value);
            }
        });

        writer.start();
        reader.start();
    }
}

输出结果： 

当前线程Thread-0:Write: 0
当前线程Thread-0:Write: 1
当前线程Thread-1:Read: 0
当前线程Thread-0:Write: 2
当前线程Thread-1:Read: 2
当前线程Thread-0:Write: 3
当前线程Thread-1:Read: 3
当前线程Thread-0:Write: 4
当前线程Thread-1:Read: 4
当前线程Thread-1:Read: 4

5. 总结

StampedLock通过引入乐观读锁来解决写线程饥饿的问题。乐观读锁不会阻塞写线程，它允许一个线程在没有写锁的情况下读取数据，并且在读取数据后，通过戳记（stamp）来验证数据是否在读取过程中被修改。如果数据没有被修改，那么读操作成功；如果数据被修改了，那么可以尝试再次获取乐观读锁或者转换为普通的读锁。

需要注意的是，StampedLock的使用比ReadWriteLock更加复杂，需要仔细处理锁的获取、验证和释放过程，以避免死锁和其他并发问题。此外，StampedLock不支持重入，因此在需要可重入锁的场景下，应该使用ReentrantLock或者其他支持重入的锁机制。