深入剖析Java并发库（JUC）之StampedLock的应用与原理

private final long WRITER_MASK = 0x8000000000000000L; // 写锁标志位
private final long NOT_LOCKED = 0L; // 锁未被持有的状态
private volatile long state; // 锁状态变量

public long tryOptimisticRead() {
    long s = state; // 获取当前锁状态
    // 检查是否有写锁被持有（通过检查最高位是否为1）
    if ((s & WRITER_MASK) != 0L) {
        // 有写锁被持有，返回0表示获取失败
        return 0L;
    } else {
        // 没有写锁被持有，返回当前状态作为stamp（乐观读锁不会改变锁状态）
        return s;
    }
}

private boolean acquireWrite(boolean interruptible, long deadline) {
    // 省略部分代码...
    long s = state, next; // 当前状态和下一个状态
    // 循环尝试获取锁直到成功或超时或中断
    while (((s & WRITER_MASK) != 0L) || ((next = tryIncWriter(s)) == 0L)) {
        // 锁被其他线程持有，根据interruptible和deadline决定等待或返回失败
        // 省略等待和中断处理逻辑...
    }
    // 成功获取写锁，设置锁持有者信息（线程和重入计数）并返回true
    // 省略设置锁持有者信息和返回逻辑...
}

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    
    // 创建一个 StampedLock 实例
    private final StampedLock stampedLock = new StampedLock();
    
    // 共享资源
    private int balance = 0;

    // 使用乐观读锁读取余额
    public int getBalanceWithOptimisticReadLock() {
        // 尝试获取乐观读锁
        long stamp = stampedLock.tryOptimisticRead();
        
        // 读取余额
        int currentBalance = balance;
        
        // 检查乐观读锁在读取过程中是否被无效（比如被写锁干扰）
        if (!stampedLock.validate(stamp)) {
            // 如果无效，则使用悲观读锁重新读取
            stamp = stampedLock.readLock();
            try {
                currentBalance = balance;
            } finally {
                // 释放悲观读锁
                stampedLock.unlockRead(stamp);
            }
        }
        
        return currentBalance;
    }
    
    // 使用悲观读锁读取余额
    public int getBalanceWithPessimisticReadLock() {
        // 获取悲观读锁
        long stamp = stampedLock.readLock();
        try {
            // 读取余额
            return balance;
        } finally {
            // 释放悲观读锁
            stampedLock.unlockRead(stamp);
        }
    }
    
    // 使用写锁更新余额
    public void updateBalanceWithWriteLock(int amount) {
        // 获取写锁
        long writeStamp = stampedLock.writeLock();
        try {
            // 更新余额
            balance += amount;
        } finally {
            // 释放写锁
            stampedLock.unlockWrite(writeStamp);
        }
    }

    public static void main(String[] args) {
        StampedLockExample example = new StampedLockExample();
        
        // 模拟多线程环境下的读写操作
        Runnable readTask = () -> {
            int balance = example.getBalanceWithOptimisticReadLock();
            System.out.println("读取到的余额（乐观读锁）: " + balance);
        };

        Runnable writeTask = () -> {
            example.updateBalanceWithWriteLock(100);
            System.out.println("更新了余额（写锁）, 新余额: " + example.getBalanceWithPessimisticReadLock());
        };

        // 启动多个读线程和写线程来模拟并发访问
        // 注意：在实际应用中，应该控制线程的数量和执行顺序以避免过度竞争和潜在的死锁风险。
        // 这里为了简化示例，并没有使用线程池或同步工具来控制线程的启动和终止。
        new Thread(readTask).start();
        new Thread(readTask).start();
        new Thread(writeTask).start();
        // ... 可以继续启动更多线程进行测试
    }
}