Movie ticket booking
Two people, one seat, the same millisecond.

Show
  String id
  Movie movie
  Screen screen
  Instant start
  Map<SeatCategory, Money> prices

ShowSeat
  String seatId
  SeatStatus status
  String holdId
  Instant holdExpiry

SeatLockManager
  hold(showId, seatIds, userId): SeatHold
  release(holdId)
  confirm(holdId)

BookingService
  holdSeats()
  confirmBooking(holdId, paymentRef): Booking
  cancel(bookingId)

Booking
  String id
  List<String> seatIds
  BookingStatus status
  Money amount

How they connect:
  Show owns ShowSeat (1 to many)
  BookingService uses SeatLockManager
  BookingService uses Booking

enum SeatStatus { AVAILABLE, HELD, BOOKED }

class ShowSeat {
    final String seatId;
    SeatStatus status = SeatStatus.AVAILABLE;
    String holdId; Instant holdExpiry;
    ShowSeat(String seatId) { this.seatId = seatId; }

    boolean isAvailable(Instant now) {
        return status == SeatStatus.AVAILABLE
            || (status == SeatStatus.HELD && holdExpiry.isBefore(now));   // lazily treat expired holds as free
    }
}

record SeatHold(String holdId, String showId, String userId, List<String> seatIds, Instant expiresAt) {}

class SeatLockManager {
    private final Map<String, Map<String, ShowSeat>> seatsByShow;         // showId → seatId → ShowSeat
    private final Map<String, ReentrantLock> showLocks = new ConcurrentHashMap<>();
    private final Map<String, SeatHold> holds = new ConcurrentHashMap<>();
    private final Duration holdTtl; private final Clock clock;

    SeatLockManager(Map<String, Map<String, ShowSeat>> seatsByShow, Duration holdTtl, Clock clock) {
        this.seatsByShow = seatsByShow; this.holdTtl = holdTtl; this.clock = clock;
    }

    public SeatHold hold(String showId, List<String> seatIds, String userId) {
        ReentrantLock lock = showLocks.computeIfAbsent(showId, k -> new ReentrantLock());
        lock.lock();                                                      // a lock per show: shows don't contend
        try {
            Instant now = clock.instant();
            Map<String, ShowSeat> seats = seatsByShow.get(showId);
            for (String id : seatIds) {                                   // 1. check ALL seats first
                ShowSeat s = seats.get(id);
                if (s == null || !s.isAvailable(now))
                    throw new SeatUnavailableException(id);
            }
            String holdId = UUID.randomUUID().toString();
            Instant expiry = now.plus(holdTtl);
            for (String id : seatIds) {                                   // 2. then hold ALL of them
                ShowSeat s = seats.get(id);
                s.status = SeatStatus.HELD; s.holdId = holdId; s.holdExpiry = expiry;
            }
            SeatHold hold = new SeatHold(holdId, showId, userId, List.copyOf(seatIds), expiry);
            holds.put(holdId, hold);
            return hold;
        } finally {
            lock.unlock();
        }
    }

    /** Called after successful payment. Fails if the hold expired and the seats were taken. */
    public void confirm(String holdId) {
        SeatHold h = holds.get(holdId);
        if (h == null) throw new IllegalStateException("Unknown hold");
        ReentrantLock lock = showLocks.get(h.showId());
        lock.lock();
        try {
            Map<String, ShowSeat> seats = seatsByShow.get(h.showId());
            for (String id : h.seatIds()) {
                ShowSeat s = seats.get(id);
                if (s.status != SeatStatus.HELD || !holdId.equals(s.holdId))
                    throw new HoldExpiredException(holdId);               // the caller must refund
            }
            h.seatIds().forEach(id -> { ShowSeat s = seats.get(id); s.status = SeatStatus.BOOKED; s.holdExpiry = null; });
            holds.remove(holdId);
        } finally { lock.unlock(); }
    }

    public void release(String holdId) {
        SeatHold h = holds.remove(holdId);
        if (h == null) return;                                            // idempotent
        ReentrantLock lock = showLocks.get(h.showId());
        lock.lock();
        try {
            Map<String, ShowSeat> seats = seatsByShow.get(h.showId());
            for (String id : h.seatIds()) {
                ShowSeat s = seats.get(id);
                if (holdId.equals(s.holdId) && s.status == SeatStatus.HELD) {
                    s.status = SeatStatus.AVAILABLE; s.holdId = null; s.holdExpiry = null;
                }
            }
        } finally { lock.unlock(); }
    }
}

class BookingService {
    private final SeatLockManager locks; private final PaymentGateway payments;
    private final Map<String, Booking> bookings = new ConcurrentHashMap<>();

    public Booking startBooking(String userId, String showId, List<String> seatIds) {
        SeatHold hold = locks.hold(showId, seatIds, userId);
        Booking b = new Booking(hold.holdId(), userId, showId, seatIds, BookingStatus.PENDING_PAYMENT, price(showId, seatIds));
        bookings.put(b.id(), b);
        return b;                                        // the client is redirected to payment with b.id() as the idempotency key
    }

    public Booking onPaymentSuccess(String bookingId, String paymentRef) {
        Booking b = bookings.get(bookingId);
        if (b.status() == BookingStatus.CONFIRMED) return b;            // idempotent webhook handling
        try {
            locks.confirm(bookingId);                                   // holdId == bookingId here
            b = b.withStatus(BookingStatus.CONFIRMED);
        } catch (HoldExpiredException e) {
            payments.refund(paymentRef);
            b = b.withStatus(BookingStatus.EXPIRED);
        }
        bookings.put(b.id(), b);
        return b;
    }
    // price(...) looks up the show's category prices
}