Introduction to StampedLock

StampedLock introduced in Java 8 is a capability-based lock with three modes for controlling read/write access. It supports optimistic reading, which can dramatically improve performance in read-heavy scenarios by avoiding writer starvation.

1. Basic StampedLock Modes

Lock Modes Overview

import java.util.concurrent.locks.StampedLock;
public class StampedLockBasic {
private final StampedLock lock = new StampedLock();
private String data = "Initial Data";
// WRITE LOCK - Exclusive access
public void writeData(String newData) {
long stamp = lock.writeLock(); // Block until write lock acquired
try {
System.out.println(Thread.currentThread().getName() + " acquired write lock");
data = newData;
Thread.sleep(1000); // Simulate write operation
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlockWrite(stamp);
System.out.println(Thread.currentThread().getName() + " released write lock");
}
}
// READ LOCK - Shared access
public String readData() {
long stamp = lock.readLock(); // Block until read lock acquired
try {
System.out.println(Thread.currentThread().getName() + " acquired read lock");
Thread.sleep(500); // Simulate read operation
return data;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return null;
} finally {
lock.unlockRead(stamp);
System.out.println(Thread.currentThread().getName() + " released read lock");
}
}
// OPTIMISTIC READ - No locking, but validation required
public String optimisticRead() {
long stamp = lock.tryOptimisticRead(); // Non-blocking
String currentData = data; // Read data optimistically
// Check if read was consistent (no write occurred during read)
if (!lock.validate(stamp)) {
System.out.println(Thread.currentThread().getName() + " optimistic read failed, upgrading to read lock");
// Fallback to read lock
stamp = lock.readLock();
try {
currentData = data;
} finally {
lock.unlockRead(stamp);
}
} else {
System.out.println(Thread.currentThread().getName() + " optimistic read succeeded");
}
return currentData;
}
public static void main(String[] args) throws InterruptedException {
StampedLockBasic example = new StampedLockBasic();
// Writer thread
Thread writer = new Thread(() -> {
example.writeData("Updated Data");
}, "Writer-Thread");
// Reader threads
Thread reader1 = new Thread(() -> {
System.out.println("Read result: " + example.readData());
}, "Reader-1");
Thread reader2 = new Thread(() -> {
System.out.println("Optimistic read result: " + example.optimisticRead());
}, "Reader-2");
writer.start();
Thread.sleep(100); // Let writer start first
reader1.start();
reader2.start();
writer.join();
reader1.join();
reader2.join();
}
}

Lock Mode Comparison

2. Optimistic Reading Patterns

Basic Optimistic Read Pattern

import java.util.concurrent.locks.StampedLock;
import java.util.concurrent.ThreadLocalRandom;
public class OptimisticReadingBasic {
private final StampedLock lock = new StampedLock();
private int counter = 0;
private String message = "Hello";
/**
* Standard pattern for optimistic reading:
* 1. tryOptimisticRead() - get stamp without blocking
* 2. Read data fields
* 3. validate(stamp) - check if read was consistent
* 4. If invalid, fallback to read lock
*/
public String readDataOptimistically() {
long stamp = lock.tryOptimisticRead();
// Capture all fields needed for consistent read
int currentCounter = counter;
String currentMessage = message;
// Critical: Validate AFTER reading all fields
if (!lock.validate(stamp)) {
// Optimistic read failed - acquire read lock
stamp = lock.readLock();
try {
currentCounter = counter;
currentMessage = message;
} finally {
lock.unlockRead(stamp);
}
}
return String.format("Counter: %d, Message: %s", currentCounter, currentMessage);
}
public void updateData(int newCounter, String newMessage) {
long stamp = lock.writeLock();
try {
// Simulate some work
Thread.sleep(ThreadLocalRandom.current().nextInt(50, 200));
counter = newCounter;
message = newMessage;
System.out.printf("Writer: Updated to counter=%d, message=%s%n", newCounter, newMessage);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlockWrite(stamp);
}
}
public static void main(String[] args) throws InterruptedException {
OptimisticReadingBasic example = new OptimisticReadingBasic();
// Start multiple readers
for (int i = 0; i < 5; i++) {
final int readerId = i;
new Thread(() -> {
for (int j = 0; j < 3; j++) {
String result = example.readDataOptimistically();
System.out.printf("Reader-%d: %s%n", readerId, result);
try {
Thread.sleep(ThreadLocalRandom.current().nextInt(100, 300));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}, "Reader-" + i).start();
}
// Start a writer
Thread writer = new Thread(() -> {
for (int i = 1; i <= 3; i++) {
example.updateData(i, "Message-" + i);
try {
Thread.sleep(500); // Write less frequently
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}, "Writer");
writer.start();
writer.join();
}
}

Complex Object Optimistic Reading

import java.util.concurrent.locks.StampedLock;
import java.util.*;
public class ComplexObjectOptimisticRead {
private final StampedLock lock = new StampedLock();
private final Map<String, Integer> dataMap = new HashMap<>();
private int version = 0;
private long lastUpdated = System.currentTimeMillis();
public ComplexObjectOptimisticRead() {
// Initialize with some data
dataMap.put("A", 1);
dataMap.put("B", 2);
dataMap.put("C", 3);
}
/**
* Optimistic read for complex object state
* Must capture ALL fields needed for consistent view
*/
public Snapshot getSnapshotOptimistically() {
long stamp = lock.tryOptimisticRead();
// Capture all fields needed for consistent snapshot
int currentVersion = version;
long currentLastUpdated = lastUpdated;
Map<String, Integer> currentDataMap = new HashMap<>(dataMap); // Defensive copy
if (!lock.validate(stamp)) {
// Fallback to read lock
stamp = lock.readLock();
try {
currentVersion = version;
currentLastUpdated = lastUpdated;
currentDataMap = new HashMap<>(dataMap);
} finally {
lock.unlockRead(stamp);
}
}
return new Snapshot(currentVersion, currentLastUpdated, currentDataMap);
}
public void updateData(String key, Integer value) {
long stamp = lock.writeLock();
try {
version++;
lastUpdated = System.currentTimeMillis();
dataMap.put(key, value);
System.out.printf("Writer: Updated %s=%d (version=%d)%n", key, value, version);
Thread.sleep(100); // Simulate write latency
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlockWrite(stamp);
}
}
public void bulkUpdate(Map<String, Integer> updates) {
long stamp = lock.writeLock();
try {
version++;
lastUpdated = System.currentTimeMillis();
dataMap.putAll(updates);
System.out.printf("Writer: Bulk update (version=%d, %d entries)%n", 
version, updates.size());
Thread.sleep(200); // Simulate longer write operation
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlockWrite(stamp);
}
}
// Snapshot class to hold consistent view
public static class Snapshot {
private final int version;
private final long lastUpdated;
private final Map<String, Integer> data;
public Snapshot(int version, long lastUpdated, Map<String, Integer> data) {
this.version = version;
this.lastUpdated = lastUpdated;
this.data = Collections.unmodifiableMap(new HashMap<>(data));
}
public int getVersion() { return version; }
public long getLastUpdated() { return lastUpdated; }
public Map<String, Integer> getData() { return data; }
@Override
public String toString() {
return String.format("Snapshot{version=%d, lastUpdated=%d, data=%s}", 
version, lastUpdated, data);
}
}
public static void main(String[] args) throws InterruptedException {
ComplexObjectOptimisticRead example = new ComplexObjectOptimisticRead();
// Start multiple readers
List<Thread> readers = new ArrayList<>();
for (int i = 0; i < 3; i++) {
final int readerId = i;
Thread reader = new Thread(() -> {
for (int j = 0; j < 5; j++) {
Snapshot snapshot = example.getSnapshotOptimistically();
System.out.printf("Reader-%d: %s%n", readerId, snapshot);
try {
Thread.sleep(150);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}, "Reader-" + i);
readers.add(reader);
reader.start();
}
// Start writers
Thread writer1 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
example.updateData("Key-" + i, i * 10);
try {
Thread.sleep(300);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}, "Writer-1");
Thread writer2 = new Thread(() -> {
Map<String, Integer> bulkData = Map.of(
"X", 100,
"Y", 200,
"Z", 300
);
example.bulkUpdate(bulkData);
}, "Writer-2");
writer1.start();
writer2.start();
// Wait for completion
writer1.join();
writer2.join();
for (Thread reader : readers) {
reader.join();
}
}
}

3. Advanced Optimistic Patterns

Try-Convert Pattern

import java.util.concurrent.locks.StampedLock;
import java.util.concurrent.ThreadLocalRandom;
public class TryConvertPattern {
private final StampedLock lock = new StampedLock();
private String data = "Initial";
private int readCount = 0;
private int writeCount = 0;
/**
* Advanced pattern: tryConvertToWriteLock
* Useful when read might need to upgrade to write
*/
public boolean updateIfCondition(String newData, String expectedCurrent) {
long stamp = lock.readLock();
try {
// Check condition under read lock
while (data.equals(expectedCurrent)) {
// Try to upgrade to write lock
long writeStamp = lock.tryConvertToWriteLock(stamp);
if (writeStamp != 0) {
// Successfully upgraded
stamp = writeStamp;
data = newData;
writeCount++;
System.out.printf("Successfully updated: %s -> %s (converted)%n", 
expectedCurrent, newData);
return true;
} else {
// Failed to upgrade, release read lock and acquire write lock
lock.unlockRead(stamp);
stamp = lock.writeLock();
// Re-check condition under write lock
if (data.equals(expectedCurrent)) {
data = newData;
writeCount++;
System.out.printf("Successfully updated: %s -> %s (write lock)%n", 
expectedCurrent, newData);
return true;
} else {
// Condition changed, no update needed
return false;
}
}
}
return false; // Condition not met
} finally {
lock.unlock(stamp);
}
}
/**
* Optimistic read with potential upgrade
*/
public String readAndConditionallyUpdate() {
long stamp = lock.tryOptimisticRead();
String currentData = data;
int currentReadCount = readCount;
if (!lock.validate(stamp)) {
// Fallback to read lock
stamp = lock.readLock();
try {
currentData = data;
currentReadCount = readCount;
} finally {
lock.unlockRead(stamp);
}
}
readCount++;
// Conditionally update based on read
if (currentReadCount % 5 == 0) {
updateIfCondition("Updated-at-" + currentReadCount, currentData);
}
return currentData;
}
public String getData() {
long stamp = lock.readLock();
try {
return data;
} finally {
lock.unlockRead(stamp);
}
}
public static void main(String[] args) throws InterruptedException {
TryConvertPattern example = new TryConvertPattern();
// Start multiple worker threads
List<Thread> workers = new ArrayList<>();
for (int i = 0; i < 5; i++) {
final int workerId = i;
Thread worker = new Thread(() -> {
for (int j = 0; j < 10; j++) {
String result = example.readAndConditionallyUpdate();
System.out.printf("Worker-%d: %s%n", workerId, result);
try {
Thread.sleep(ThreadLocalRandom.current().nextInt(50, 150));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}, "Worker-" + i);
workers.add(worker);
worker.start();
}
for (Thread worker : workers) {
worker.join();
}
System.out.println("Final data: " + example.getData());
}
}

Time-Bounded Operations

import java.util.concurrent.locks.StampedLock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadLocalRandom;
public class TimeBoundedOperations {
private final StampedLock lock = new StampedLock();
private String data = "Initial Data";
private final long version = 1L;
/**
* Try optimistic read with timeout fallback
*/
public String readWithTimeout(long timeout, TimeUnit unit) {
long startTime = System.nanoTime();
long timeoutNanos = unit.toNanos(timeout);
// First attempt: optimistic read
long stamp = lock.tryOptimisticRead();
String currentData = data;
if (lock.validate(stamp)) {
System.out.println(Thread.currentThread().getName() + ": Optimistic read succeeded");
return currentData;
}
// Optimistic read failed, try timed read lock
try {
stamp = lock.tryReadLock(timeoutNanos, TimeUnit.NANOSECONDS);
if (stamp != 0) {
try {
long elapsed = System.nanoTime() - startTime;
System.out.printf("%s: Read lock acquired after %d ms%n", 
Thread.currentThread().getName(), 
TimeUnit.NANOSECONDS.toMillis(elapsed));
currentData = data;
return currentData;
} finally {
lock.unlockRead(stamp);
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
// Timeout or interrupt
System.out.println(Thread.currentThread().getName() + ": Read timeout");
return "Timeout - unable to read";
}
/**
* Try write lock with timeout
*/
public boolean writeWithTimeout(String newData, long timeout, TimeUnit unit) {
try {
long stamp = lock.tryWriteLock(timeout, unit);
if (stamp != 0) {
try {
data = newData;
System.out.println(Thread.currentThread().getName() + ": Write completed");
return true;
} finally {
lock.unlockWrite(stamp);
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println(Thread.currentThread().getName() + ": Write timeout");
return false;
}
/**
* Optimistic read with retry mechanism
*/
public String optimisticReadWithRetry(int maxRetries) {
for (int attempt = 1; attempt <= maxRetries; attempt++) {
long stamp = lock.tryOptimisticRead();
String currentData = data;
if (lock.validate(stamp)) {
System.out.printf("%s: Optimistic read succeeded on attempt %d%n", 
Thread.currentThread().getName(), attempt);
return currentData;
}
// Brief backoff before retry
if (attempt < maxRetries) {
try {
Thread.sleep(ThreadLocalRandom.current().nextInt(10, 50));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
// All optimistic attempts failed, fallback to read lock
long stamp = lock.readLock();
try {
System.out.printf("%s: Fell back to read lock after %d retries%n", 
Thread.currentThread().getName(), maxRetries);
return data;
} finally {
lock.unlockRead(stamp);
}
}
public static void main(String[] args) throws InterruptedException {
TimeBoundedOperations example = new TimeBoundedOperations();
// Writer thread that holds lock for varying durations
Thread writer = new Thread(() -> {
for (int i = 0; i < 3; i++) {
boolean success = example.writeWithTimeout("Data-" + i, 2, TimeUnit.SECONDS);
if (success) {
try {
// Hold write lock for varying times
Thread.sleep(ThreadLocalRandom.current().nextInt(500, 1500));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
}, "Writer");
// Reader threads with different strategies
Thread timeoutReader = new Thread(() -> {
for (int i = 0; i < 5; i++) {
String result = example.readWithTimeout(500, TimeUnit.MILLISECONDS);
System.out.println("TimeoutReader got: " + result);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}, "TimeoutReader");
Thread retryReader = new Thread(() -> {
for (int i = 0; i < 5; i++) {
String result = example.optimisticReadWithRetry(3);
System.out.println("RetryReader got: " + result);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}, "RetryReader");
writer.start();
timeoutReader.start();
retryReader.start();
writer.join();
timeoutReader.join();
retryReader.join();
}
}

4. Performance Comparison

Benchmark: ReadLock vs Optimistic Read

import java.util.concurrent.locks.StampedLock;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
public class PerformanceComparison {
private final StampedLock lock = new StampedLock();
private final AtomicLong data = new AtomicLong(0);
private final int READER_COUNT = 10;
private final int WRITER_COUNT = 2;
private final int OPERATIONS_PER_THREAD = 10000;
/**
* Traditional read lock approach
*/
public long readWithReadLock() {
long stamp = lock.readLock();
try {
return data.get();
} finally {
lock.unlockRead(stamp);
}
}
/**
* Optimistic read approach
*/
public long readWithOptimisticLock() {
long stamp = lock.tryOptimisticRead();
long value = data.get();
if (!lock.validate(stamp)) {
// Fallback to read lock
stamp = lock.readLock();
try {
value = data.get();
} finally {
lock.unlockRead(stamp);
}
}
return value;
}
public void write(long newValue) {
long stamp = lock.writeLock();
try {
data.set(newValue);
} finally {
lock.unlockWrite(stamp);
}
}
public void runBenchmark() throws InterruptedException {
System.out.println("=== StampedLock Performance Comparison ===");
System.out.printf("Readers: %d, Writers: %d, Operations per thread: %d%n%n", 
READER_COUNT, WRITER_COUNT, OPERATIONS_PER_THREAD);
// Test with read locks
testWithReadLocks();
// Test with optimistic reads
testWithOptimisticReads();
}
private void testWithReadLocks() throws InterruptedException {
data.set(0);
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(READER_COUNT + WRITER_COUNT);
AtomicLong totalReadTime = new AtomicLong(0);
AtomicLong readCount = new AtomicLong(0);
// Create readers
for (int i = 0; i < READER_COUNT; i++) {
new Thread(() -> {
try {
startLatch.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
for (int j = 0; j < OPERATIONS_PER_THREAD; j++) {
long startTime = System.nanoTime();
readWithReadLock();
long endTime = System.nanoTime();
totalReadTime.addAndGet(endTime - startTime);
readCount.incrementAndGet();
}
endLatch.countDown();
}).start();
}
// Create writers
for (int i = 0; i < WRITER_COUNT; i++) {
new Thread(() -> {
try {
startLatch.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
for (int j = 0; j < OPERATIONS_PER_THREAD / 10; j++) { // Fewer writes
write(ThreadLocalRandom.current().nextLong());
try {
Thread.sleep(1); // Simulate write work
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
endLatch.countDown();
}).start();
}
// Run test
long startTime = System.nanoTime();
startLatch.countDown();
endLatch.await();
long totalTime = System.nanoTime() - startTime;
System.out.println("=== READ LOCK RESULTS ===");
printResults(totalTime, totalReadTime.get(), readCount.get());
}
private void testWithOptimisticReads() throws InterruptedException {
data.set(0);
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(READER_COUNT + WRITER_COUNT);
AtomicLong totalReadTime = new AtomicLong(0);
AtomicLong readCount = new AtomicLong(0);
AtomicLong optimisticSuccess = new AtomicLong(0);
// Create readers
for (int i = 0; i < READER_COUNT; i++) {
new Thread(() -> {
try {
startLatch.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
for (int j = 0; j < OPERATIONS_PER_THREAD; j++) {
long startTime = System.nanoTime();
long value = readWithOptimisticLock();
long endTime = System.nanoTime();
totalReadTime.addAndGet(endTime - startTime);
readCount.incrementAndGet();
// Track optimistic success rate (simplified)
if (value >= 0) { // In real scenario, track actual optimistic success
optimisticSuccess.incrementAndGet();
}
}
endLatch.countDown();
}).start();
}
// Create writers (same as before)
for (int i = 0; i < WRITER_COUNT; i++) {
new Thread(() -> {
try {
startLatch.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
for (int j = 0; j < OPERATIONS_PER_THREAD / 10; j++) {
write(ThreadLocalRandom.current().nextLong());
try {
Thread.sleep(1);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
endLatch.countDown();
}).start();
}
// Run test
long startTime = System.nanoTime();
startLatch.countDown();
endLatch.await();
long totalTime = System.nanoTime() - startTime;
System.out.println("=== OPTIMISTIC READ RESULTS ===");
printResults(totalTime, totalReadTime.get(), readCount.get());
System.out.printf("Optimistic success rate: %.2f%%%n%n", 
(optimisticSuccess.get() * 100.0 / readCount.get()));
}
private void printResults(long totalTime, long totalReadTime, long readCount) {
double totalMs = totalTime / 1_000_000.0;
double avgReadTimeNs = totalReadTime / (double) readCount;
System.out.printf("Total time: %.2f ms%n", totalMs);
System.out.printf("Average read time: %.2f ns%n", avgReadTimeNs);
System.out.printf("Throughput: %.2f operations/ms%n%n", 
readCount / totalMs);
}
public static void main(String[] args) throws InterruptedException {
PerformanceComparison benchmark = new PerformanceComparison();
benchmark.runBenchmark();
}
}

5. Real-World Use Cases

Cached Data with StampedLock

import java.util.concurrent.locks.StampedLock;
import java.util.*;
import java.util.concurrent.*;
public class CachedDataWithStampedLock {
private final StampedLock lock = new StampedLock();
private final Map<String, CacheEntry> cache = new HashMap<>();
private final long cacheTimeoutMs;
public CachedDataWithStampedLock(long cacheTimeoutMs) {
this.cacheTimeoutMs = cacheTimeoutMs;
}
/**
* Get data with optimistic read for cache hit
*/
public String get(String key) {
// First attempt: optimistic read
long stamp = lock.tryOptimisticRead();
CacheEntry entry = cache.get(key);
if (entry != null && !isExpired(entry) && lock.validate(stamp)) {
// Fast path: cache hit with optimistic read
recordCacheHit("optimistic");
return entry.data;
}
// Slow path: acquire read lock
stamp = lock.readLock();
try {
entry = cache.get(key);
if (entry != null && !isExpired(entry)) {
recordCacheHit("readLock");
return entry.data;
}
} finally {
lock.unlockRead(stamp);
}
// Cache miss - load data
return loadData(key);
}
/**
* Load data with write lock
*/
private String loadData(String key) {
long stamp = lock.writeLock();
try {
// Double-check under write lock
CacheEntry existing = cache.get(key);
if (existing != null && !isExpired(existing)) {
recordCacheHit("writeLock-doubleCheck");
return existing.data;
}
// Simulate expensive data loading
String data = expensiveLoadOperation(key);
cache.put(key, new CacheEntry(data, System.currentTimeMillis()));
recordCacheMiss();
return data;
} finally {
lock.unlockWrite(stamp);
}
}
/**
* Bulk update cache
*/
public void bulkUpdate(Map<String, String> newData) {
long stamp = lock.writeLock();
try {
long now = System.currentTimeMillis();
for (Map.Entry<String, String> entry : newData.entrySet()) {
cache.put(entry.getKey(), new CacheEntry(entry.getValue(), now));
}
System.out.println("Bulk updated " + newData.size() + " entries");
} finally {
lock.unlockWrite(stamp);
}
}
/**
* Clear expired entries
*/
public void cleanup() {
long stamp = lock.writeLock();
try {
Iterator<Map.Entry<String, CacheEntry>> it = cache.entrySet().iterator();
int removed = 0;
while (it.hasNext()) {
if (isExpired(it.next().getValue())) {
it.remove();
removed++;
}
}
System.out.println("Cleaned up " + removed + " expired entries");
} finally {
lock.unlockWrite(stamp);
}
}
private boolean isExpired(CacheEntry entry) {
return System.currentTimeMillis() - entry.timestamp > cacheTimeoutMs;
}
private String expensiveLoadOperation(String key) {
try {
Thread.sleep(100); // Simulate expensive operation
return "Data-for-" + key + "-" + System.currentTimeMillis();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Load interrupted", e);
}
}
// Statistics
private final Map<String, AtomicLong> stats = new ConcurrentHashMap<>();
private void recordCacheHit(String type) {
stats.computeIfAbsent("hit." + type, k -> new AtomicLong()).incrementAndGet();
}
private void recordCacheMiss() {
stats.computeIfAbsent("miss", k -> new AtomicLong()).incrementAndGet();
}
public void printStats() {
System.out.println("\n=== Cache Statistics ===");
stats.forEach((key, value) -> System.out.printf("%s: %d%n", key, value.get()));
}
private static class CacheEntry {
final String data;
final long timestamp;
CacheEntry(String data, long timestamp) {
this.data = data;
this.timestamp = timestamp;
}
}
public static void main(String[] args) throws InterruptedException {
CachedDataWithStampedLock cache = new CachedDataWithStampedLock(5000); // 5 second timeout
// Start readers
List<Thread> readers = new ArrayList<>();
for (int i = 0; i < 10; i++) {
final int readerId = i;
Thread reader = new Thread(() -> {
for (int j = 0; j < 20; j++) {
String key = "key-" + (j % 5); // Limited key set for cache hits
String data = cache.get(key);
System.out.printf("Reader-%d: %s = %s%n", readerId, key, data);
try {
Thread.sleep(ThreadLocalRandom.current().nextInt(50, 200));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
readers.add(reader);
reader.start();
}
// Start periodic writer
Thread writer = new Thread(() -> {
for (int i = 0; i < 3; i++) {
Map<String, String> updates = Map.of(
"key-0", "updated-" + i,
"key-1", "updated-" + i,
"key-6", "new-key-" + i
);
cache.bulkUpdate(updates);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
writer.start();
// Start cleanup
Thread cleanup = new Thread(() -> {
for (int i = 0; i < 2; i++) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
cache.cleanup();
}
});
cleanup.start();
// Wait for completion
for (Thread reader : readers) {
reader.join();
}
writer.join();
cleanup.join();
cache.printStats();
}
}

6. Best Practices and Pitfalls

StampedLock Best Practices

import java.util.concurrent.locks.StampedLock;
public class StampedLockBestPractices {
private final StampedLock lock = new StampedLock();
private String data1 = "Data1";
private String data2 = "Data2";
private int version = 0;
/**
* GOOD: Proper optimistic read pattern
*/
public String readConsistentDataGood() {
long stamp = lock.tryOptimisticRead();
// Read ALL related fields before validation
String currentData1 = data1;
String currentData2 = data2;
int currentVersion = version;
// Validate AFTER reading all fields
if (!lock.validate(stamp)) {
// Fallback to read lock
stamp = lock.readLock();
try {
currentData1 = data1;
currentData2 = data2;
currentVersion = version;
} finally {
lock.unlockRead(stamp);
}
}
return String.format("%s, %s (v%d)", currentData1, currentData2, currentVersion);
}
/**
* BAD: Incorrect optimistic read - validation between reads
*/
public String readConsistentDataBad() {
long stamp = lock.tryOptimisticRead();
String currentData1 = data1;
// WRONG: Validating between reads breaks consistency
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
currentData1 = data1;
} finally {
lock.unlockRead(stamp);
}
}
String currentData2 = data2; // This might be inconsistent with data1!
return String.format("%s, %s", currentData1, currentData2);
}
/**
* GOOD: Always use try-finally with locks
*/
public void updateDataGood(String newData1, String newData2) {
long stamp = lock.writeLock();
try {
data1 = newData1;
data2 = newData2;
version++;
} finally {
lock.unlockWrite(stamp); // ALWAYS in finally block
}
}
/**
* BAD: Risk of not releasing lock on exception
*/
public void updateDataBad(String newData1, String newData2) {
long stamp = lock.writeLock();
data1 = newData1;
data2 = newData2;
version++;
lock.unlockWrite(stamp); // Not in finally - risky!
}
/**
* GOOD: Proper tryConvert usage
*/
public boolean conditionalUpdateGood(String expected, String newValue) {
long stamp = lock.readLock();
try {
while (data1.equals(expected)) {
long writeStamp = lock.tryConvertToWriteLock(stamp);
if (writeStamp != 0) {
stamp = writeStamp;
data1 = newValue;
return true;
} else {
lock.unlockRead(stamp);
stamp = lock.writeLock();
// Re-check condition under write lock
if (data1.equals(expected)) {
data1 = newValue;
return true;
}
return false;
}
}
return false;
} finally {
lock.unlock(stamp);
}
}
/**
* AVOID: Using synchronized with StampedLock
*/
public void methodWithSynchronized() {
synchronized (this) {
// This can cause deadlocks with StampedLock
long stamp = lock.writeLock(); // DANGEROUS!
try {
// ...
} finally {
lock.unlockWrite(stamp);
}
}
}
/**
* GOOD: Use ThreadLocalRandom instead of Random in concurrent code
*/
public void concurrentRandomAccess() {
long stamp = lock.readLock();
try {
// ThreadLocalRandom is thread-safe and faster
int randomValue = java.util.concurrent.ThreadLocalRandom.current().nextInt(100);
// Use randomValue...
} finally {
lock.unlockRead(stamp);
}
}
}

Summary

Key Benefits of StampedLock Optimistic Reading:

1. Performance: Avoids lock acquisition for read-heavy, low-contention scenarios
2. Non-blocking: Optimistic reads never block
3. Writer Fairness: Prevents writer starvation common in ReadWriteLock
4. Flexibility: Multiple lock modes and conversion capabilities

When to Use Optimistic Reading:

• Read-heavy workloads with infrequent writes
• Low contention scenarios
• Large read operations where lock acquisition overhead is significant
• When reads can tolerate occasional retries

Best Practices:

1. Always validate optimistic reads after reading all fields
2. Use try-finally for lock cleanup
3. Provide fallback to read lock when optimistic read fails
4. Avoid nested locking with other synchronization mechanisms
5. Use tryConvertToWriteLock for read-to-write upgrades

Performance Characteristics:

• Optimistic Read: ~10-50ns (when successful)
• Read Lock: ~100-200ns
• Write Lock: ~200-500ns
• Optimistic Fallback: Additional cost of read lock acquisition

StampedLock with optimistic reading provides excellent performance for read-dominated workloads while maintaining data consistency and writer fairness.