📝 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.

🚚 Delivery Truck Loading System Concurrency Problem

Table of contents