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 {
        // 處理數(shù)據(jù)
    } finally {
        lock.unlockRead(stamp);
    }
} catch (InterruptedException e) {
    // 處理中斷
}