ReadWriteLock

Standard locks enforce complete mutual exclusion, restricting throughput even when threads are only reading. ReadWriteLock divides access between multiple parallel readers and a single exclusive writer.

Lock Rules & Downgrading

A ReentrantReadWriteLock follows these coordination rules:

• Read Lock: Multiple threads can hold it concurrently, provided no write lock is active.
• Write Lock: Only one thread can hold it. Readers and other writers are blocked.
• Lock Downgrading: A thread holding the write lock can acquire the read lock, then release the write lock. This is safe and keeps the resource visible.
• Lock Promotion (Not Allowed): A thread holding the read lock cannot acquire the write lock directly without first releasing the read lock, as this can cause deadlocks if multiple readers attempt it simultaneously.

Code Walkthrough

This class implements a thread-safe data cache using ReentrantReadWriteLock to allow high-throughput concurrent reads.

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class CacheService {
    private final Map cache = new HashMap<>();
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
public String get(String key) {
        rwLock.readLock().lock(); // Multiple threads can execute this concurrently
        try {
            return cache.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }
public void put(String key, String value) {
        rwLock.writeLock().lock(); // Exclusive lock: blocks readers and other writers
        try {
            cache.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

Interview-Relevant Information