Broken — read-check-write gap under READ COMMITTED

@Transactional
public void reserveBroken(List<Long> seatIds, long userId) {
    List<Seat> seats = seatRepo.findAllById(seatIds);
    if (seats.stream().anyMatch(s -> !"available".equals(s.getStatus()))) {
        throw new SeatsNotAvailableException();
    }
    seats.forEach(s -> {
        s.setStatus("reserved");
        s.setHeldBy(userId);
        s.setHeldUntil(Instant.now().plus(Duration.ofMinutes(10)));
    });
    seatRepo.saveAll(seats);  // both TXs may commit overlapping seats
}

Production — ordered pessimistic lock, all-or-nothing (Spring JDBC)

@Transactional
public ReservationResponse reserve(List<Long> seatIds, long userId) {
    List<Long> sortedIds = seatIds.stream().distinct().sorted().toList();
    if (sortedIds.isEmpty() || sortedIds.size() > 6) {
        throw new IllegalArgumentException("Select 1–6 seats");
    }

    String lockSql = """
        SELECT id, status FROM seats
        WHERE id = ANY (?)
        ORDER BY id
        FOR NO KEY UPDATE
        """;

    List<Seat> locked = jdbc.query(lockSql,
        ps -> ps.setArray(1, ps.getConnection()
            .createArrayOf("bigint", sortedIds.toArray(Long[]::new))),
        seatRowMapper);

    if (locked.size() != sortedIds.size()) {
        throw new SeatsNotFoundException(sortedIds);
    }
    List<Long> taken = locked.stream()
        .filter(s -> !"available".equals(s.getStatus()))
        .map(Seat::getId)
        .toList();
    if (!taken.isEmpty()) {
        throw new SeatsNotAvailableException(taken);
    }

    Instant expiresAt = Instant.now().plus(Duration.ofMinutes(10));
    String updateSql = """
        UPDATE seats
        SET status = 'reserved', held_by = ?, held_until = ?, version = version + 1
        WHERE id = ANY (?) AND status = 'available'
        """;

    int updated = jdbc.update(updateSql,
        userId, Timestamp.from(expiresAt), sortedIds.toArray(Long[]::new));
    if (updated != sortedIds.size()) {
        throw new ConcurrentModificationException("Seat race during update");
    }
    return new ReservationResponse(sortedIds, userId, expiresAt);
}

Single-seat fast path — one atomic UPDATE, no explicit transaction

public boolean claimSeat(long seatId, long userId) {
    int n = jdbc.update("""
        UPDATE seats
        SET status = 'reserved',
            held_by = ?,
            held_until = now() + interval '10 minutes'
        WHERE id = ? AND status = 'available'
        """, userId, seatId);
    return n == 1;
}

Interview quick-fire