Let's model a warehouse system where multiple workers pack orders concurrently while managing shared resources.

Problem Statement

Multiple packing stations process orders simultaneously
Shared inventory with limited stock
Orders may require multiple items
Prevent race conditions during inventory access
Handle backorders when stock is insufficient

Solution Approaches

Basic Solution

public class Warehouse {
    private Map<String, Integer> inventory = new HashMap<>();

    public boolean pickItem(String sku, int quantity) {
        if (inventory.getOrDefault(sku, 0) >= quantity) {
            inventory.put(sku, inventory.get(sku) - quantity);
            return true;
        }
        return false;
    }

    public void restock(String sku, int quantity) {
        inventory.put(sku, inventory.getOrDefault(sku, 0) + quantity);
    }
}

public class PackingStation {
    public void processOrder(Order order, Warehouse warehouse) {
        for (Map.Entry<String, Integer> item : order.getItems().entrySet()) {
            if (!warehouse.pickItem(item.getKey(), item.getValue())) {
                order.backorder();
                return;
            }
        }
        order.pack();
    }
}

Problems

Race Condition: Two threads can oversell stock

Dirty Reads: Temporary negative inventory possible
Lost Updates: Restocks might get overwritten

Fix for Above mentioned problem: Coarse-Grained Synchronization

public class Warehouse {
    private Map<String, Integer> inventory = new HashMap<>();

    public synchronized boolean pickItem(String sku, int quantity) {
        if (inventory.getOrDefault(sku, 0) >= quantity) {
            inventory.put(sku, inventory.get(sku) - quantity);
            return true;
        }
        return false;
    }

    public synchronized void restock(String sku, int quantity) {
        inventory.put(sku, inventory.getOrDefault(sku, 0) + quantity);
    }
}

Solves race conditions with method-level synchronized
Ensures atomic inventory updates

New Problems

Throughput Bottleneck:

Entire warehouse locks during each operation
Packing station working with SKU-A blocks SKU-B access

Deadlock Risk:

// Thread 1
synchronized void processOrder() {
    pickItem("A", 1);
    pickItem("B", 1); // Deadlock if Thread 2 holds B and wants A
}

Fix and other solution will be covered in our course.

📦 Warehouse Packing Simulation Concurrency Problem

Table of contents