How Read‑Write Lock Separation Supercharges E‑Commerce Inventory

Read‑Write Lock Separation Design Pattern

The pattern is intended for scenarios where read operations vastly outnumber write operations. It uses a ReadWriteLock that provides a shared read lock and an exclusive write lock, allowing concurrent reads while guaranteeing exclusive writes to preserve data consistency.

Principles

ReadWriteLock

Provides a readLock() (shared) and a writeLock() (exclusive).

Multiple threads can hold the read lock simultaneously.

The write lock blocks all other reads and writes until it is released.

Applicable Scenarios

Read‑heavy workloads such as cache reads, configuration reads, or analytical queries.

Read‑write separation reduces read blocking and improves throughput.

Business Requirements for Inventory Management

High‑concurrency reads : Thousands of users may query product stock concurrently.

Real‑time stock updates : Orders, cancellations, and restocking modify stock infrequently but must be thread‑safe.

Data consistency : Writes must be exclusive; reads must never see intermediate states.

Read‑many / write‑few : The majority of operations are stock queries.

Performance : Stock‑query latency directly impacts user experience during promotions.

Implementation Steps

Define an InventoryManager class that holds a Map<String, Integer> for product stock and a ReentrantReadWriteLock instance.

Implement checkStock(String productId) to acquire the read lock, read the map, and release the lock.

Implement updateStock(String productId, int quantity) to acquire the write lock, modify the map, log the change, and release the lock.

Code

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class InventoryManager {
    private final Map<String, Integer> inventory = new HashMap<>();
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();

    // Read operation
    public int checkStock(String productId) {
        readLock.lock();
        try {
            return inventory.getOrDefault(productId, 0);
        } finally {
            readLock.unlock();
        }
    }

    // Write operation
    public void updateStock(String productId, int quantity) {
        writeLock.lock();
        try {
            int current = inventory.getOrDefault(productId, 0);
            inventory.put(productId, current + quantity);
            System.out.println("Updated stock for product " + productId + ": " + (current + quantity));
        } finally {
            writeLock.unlock();
        }
    }
}

Test Case

public class InventoryManagerTest {
    public static void main(String[] args) {
        InventoryManager manager = new InventoryManager();
        manager.updateStock("product_1", 100); // initial stock

        // Simulate concurrent readers
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                System.out.println("Stock for product_1: " + manager.checkStock("product_1"));
            }).start();
        }

        // Simulate a writer
        new Thread(() -> {
            manager.updateStock("product_1", -10);
            System.out.println("Stock after selling 10 units: " + manager.checkStock("product_1"));
        }).start();
    }
}

Analysis

Read operation ( checkStock ) : Acquires only the read lock, allowing multiple reader threads to execute concurrently without blocking each other.

Write operation ( updateStock ) : Acquires the exclusive write lock, blocking all other reads and writes until the update completes, thus preventing data races.

Sample Output

Stock for product_1: 100
Stock for product_1: 100
Stock for product_1: 100
Stock for product_1: 100
Stock for product_1: 100
Updated stock for product product_1: 90
Stock after selling 10 units: 90

Advantages and Disadvantages

Advantages : Enables high read concurrency, reduces read‑write contention, and fits read‑many/write‑few workloads such as e‑commerce inventory queries.

Disadvantages : If write frequency increases, the exclusive write lock can become a bottleneck, temporarily degrading read performance.