Java StampedLock实现原理与最佳实践记录

StampedLock lock = new StampedLock();
long stamp = lock.writeLock(); // 获取写锁
try {
    // 写入共享变量
} finally {
    lock.unlockWrite(stamp); // 释放写锁
}

long stamp = lock.readLock(); // 获取悲观读锁
try {
    // 读取共享变量
} finally {
    lock.unlockRead(stamp); // 释放读锁
}

long stamp = lock.tryOptimisticRead(); // 获取乐观读戳记
// 读取共享变量
if (!lock.validate(stamp)) { // 验证戳记是否有效
    // 升级为悲观读锁
    stamp = lock.readLock();
    try {
        // 重新读取共享变量
    } finally {
        lock.unlockRead(stamp);
    }
}

public class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();
    // 写入方法
    void move(double deltaX, double deltaY) {
        long stamp = sl.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }
    }
    // 乐观读方法
    double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead();
        double currentX = x, currentY = y;
        if (!sl.validate(stamp)) {
            stamp = sl.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

public class DataContainer {
    private final StampedLock lock = new StampedLock();
    private double data;
    public void transformData() {
        long stamp = lock.tryOptimisticRead();
        double currentData = data;
        // 检查是否需要更新
        if (needsUpdate(currentData)) {
            // 升级为写锁
            long writeStamp = lock.tryConvertToWriteLock(stamp);
            if (writeStamp != 0L) {
                try {
                    data = computeNewValue(currentData);
                } finally {
                    lock.unlockWrite(writeStamp);
                }
            } else {
                // 升级失败，回退到普通的写锁获取
                stamp = lock.writeLock();
                try {
                    data = computeNewValue(data);
                } finally {
                    lock.unlockWrite(stamp);
                }
            }
        }
    }
}

try {
    long stamp = lock.readLockInterruptibly();
    try {
        // 处理数据
    } finally {
        lock.unlockRead(stamp);
    }
} catch (InterruptedException e) {
    // 处理中断
}