How do you handle the book reservation system in LLD?

Direct Answer

Use a queue per Book to store Reservations in order. When a Member reserves, append to the queue. On BookItem return, the Book checks its reservation queue and notifies the first Member. Implement Observer pattern where BookItem notifies Book of status changes, and Book processes the next pending Reservation.

Deep Dive & Architecture

Reserve the title and fulfil with a copy

A member usually reserves a title when every copy is unavailable. The title keeps an ordered queue of active reservations. A reservation records the member, request time, status, and—after fulfilment—the copy assigned to it. Duplicate active reservations by the same member can be rejected.

A return creates a temporary hold

When a copy is returned, the service removes expired or invalid reservations, selects the next eligible member, marks the copy HELD, and sets a pickup deadline. It then sends a notification. If the deadline passes, the hold expires and the same copy is offered to the next member; if the queue is empty, the copy becomes AVAILABLE.

The claim must be atomic

Two returned copies or two service instances must not fulfil the same reservation. The storage operation should conditionally change one reservation from WAITING to READY and one copy from RETURNED to HELD in the same transaction. A queue describes ordering, but the transactional state change is what prevents double allocation.

Code Example

class Book {
    private final Queue<Reservation> reservations = new LinkedList<>();   // FIFO = fairness

    void reserve(Member m) { reservations.add(new Reservation(m, LocalDateTime.now())); }

    // called when any copy of this title is returned (Observer callback)
    void onCopyReturned(BookItem item) {
        Reservation next = reservations.poll();      // head of queue
        if (next != null) {
            item.markReserved();
            NotificationService.notify(next.member(), "Your reserved book is available");
        } else {
            item.markAvailable();
        }
    }
}
record Reservation(Member member, LocalDateTime at) {}

FIFO Queue guarantees first-come-first-served; the returned copy is held for the head member.

Common Mistakes & Pitfalls

• Using a Set or list without order — breaks first-come-first-served fairness; use a Queue.
• Coupling return logic to notifications — a returned book directly emailing users. Use Observer so the Book decides.
• No hold/expiry — the reserved copy should be held only for a window, then offered to the next member.
• Reserving at BookItem level — reservations are per title (Book), satisfied by any copy.