📝 Problem Setup

A logistics company has multiple loading docks where workers load packages into delivery trucks.

Each truck has a weight/volume limit.
Packages arrive continuously from the warehouse.
Multiple workers can attempt to load packages in parallel.
Once a truck is full, it should be dispatched immediately, and a new empty truck should arrive at the dock.

⚠️ Concurrency Challenge

Naive approach:
Each worker checks whether the truck has space left and then puts the package in.

Problems

Two workers check simultaneously → both see “space available.”
Both load packages → truck exceeds capacity.
Or, one worker sees “truck is full,” but another worker just dispatched it → confusion: packages might get lost or assigned incorrectly.

🔑 Solution Approaches

1. Naive Locking

Place a synchronized lock on the truck while loading.
Multiple workers try to load packages onto a dock’s current truck.
- Correctness first: never overfill a truck; never dispatch twice; never lose a package.
  - Only one worker can load at a time.
We’ll serialize critical operations with a single lock so only one worker mutates truck state at a time.

🔒 Locking plan (coarse-grained / “monitor”)

Use one monitor lock per dock (i.e., synchronized on the Dock instance).
- Why lock the dock (not the truck)?
  - We will discuss this in our course.
Every operation that reads + writes truck capacity/used/state runs inside the same lock.
The whole sequence check → load → maybe dispatch → maybe replace is atomic w.r.t. other workers.

Code

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class NaiveDockLoading {

    // Simple package with a weight
    static class Package {
        final int id;
        final int weight;
        Package(int id, int weight) { this.id = id; this.weight = weight; }
        @Override public String toString() { return "Pkg#" + id + "(" + weight + ")"; }
    }

    enum TruckState { EMPTY, LOADING, FULL, DISPATCHED }

    static class Truck {
        final int id;
        final int capacity;
        int used = 0;
        TruckState state = TruckState.EMPTY;
        final List<Package> loaded = new ArrayList<>();

        Truck(int id, int capacity) {
            this.id = id;
            this.capacity = capacity;
        }
    }

    static class Dock {
        private final int truckCapacity;
        private final AtomicInteger truckSeq = new AtomicInteger(1);
        private Truck currentTruck;

        // One coarse-grained lock: the Dock object itself
        Dock(int truckCapacity) {
            this.truckCapacity = truckCapacity;
            this.currentTruck = new Truck(truckSeq.getAndIncrement(), truckCapacity);
        }

        // Called by many worker threads
        public void load(Package pkg) {
            synchronized (this) {
                ensureActiveTruck();

                // If it doesn't fit, dispatch and replace, then load on the new truck.
                if (!fits(pkg, currentTruck)) {
                    dispatchLocked(currentTruck);
                    currentTruck = new Truck(truckSeq.getAndIncrement(), truckCapacity);
                }

                // Now it must fit
                placeLocked(pkg, currentTruck);

                // If truck just became full, dispatch and replace
                if (currentTruck.used == currentTruck.capacity) {
                    currentTruck.state = TruckState.FULL;
                    dispatchLocked(currentTruck);
                    currentTruck = new Truck(truckSeq.getAndIncrement(), truckCapacity);
                }
            } // lock released
        }

        private void ensureActiveTruck() {
            if (currentTruck.state == TruckState.DISPATCHED) {
                currentTruck = new Truck(truckSeq.getAndIncrement(), truckCapacity);
            }
        }

        private static boolean fits(Package p, Truck t) {
            return t.used + p.weight <= t.capacity && t.state != TruckState.DISPATCHED;
        }

        private static void placeLocked(Package p, Truck t) {
            // Inside dock lock: check+update is atomic
            if (t.state == TruckState.DISPATCHED) {
                throw new IllegalStateException("Cannot load on dispatched truck " + t.id);
            }
            if (t.used + p.weight > t.capacity) {
                throw new IllegalStateException("Overfill prevented for truck " + t.id);
            }
            if (t.used == 0) t.state = TruckState.LOADING;
            t.loaded.add(p);
            t.used += p.weight;
            System.out.printf("[DOCK] Loaded %s on truck #%d (used=%d/%d)%n",
                    p, t.id, t.used, t.capacity);
        }

        private static void dispatchLocked(Truck t) {
            if (t.state == TruckState.DISPATCHED) return; // idempotent
            t.state = TruckState.DISPATCHED;
            System.out.printf("[DISPATCH] Truck #%d dispatched with %d/%d (packages=%d)%n",
                    t.id, t.used, t.capacity, t.loaded.size());
            // In naive solution: pretend to hand off to transport subsystem here.
            // Avoid I/O here to keep critical section small (still naive, but less awful).
        }
    }

    // Demo harness: many workers calling Dock.load(...)
    public static void main(String[] args) throws InterruptedException {
        Dock dock = new Dock(/*truckCapacity*/ 100);

        // Create a pool of workers; they all contend on the same dock lock.
        ExecutorService workers = Executors.newFixedThreadPool(8);

        // Generate random packages totaling more than a few trucks
        List<Package> incoming = new ArrayList<>();
        Random r = new Random(42);
        for (int i = 1; i <= 60; i++) {
            int w = 5 + r.nextInt(30); // 5..34
            incoming.add(new Package(i, w));
        }

        for (Package p : incoming) {
            workers.submit(() -> dock.load(p));
        }

        workers.shutdown();
        workers.awaitTermination(1, TimeUnit.MINUTES);
        System.out.println("Done.");
    }
}

⏱️ Performance & limits (what breaks first)

All workers queue behind the dock lock; CPU underutilization grows as worker count rises.
Even if you wanted to prepare a new truck in parallel, the single lock blocks it.
Java’s intrinsic locks are not fair; a thread might repeatedly win the lock (“lock hogging”), causing starvation under load spikes.
If package arrival rate > service rate, the work queue grows unbounded (in this naive example, we submit tasks freely).

More Better Solutions Approaches and Fix for above problems will be covered in our course.

https://youtu.be/PG7MUTlWl-U

🚚 Delivery Truck Loading System Concurrency Problem

Table of contents