Add bookmyshow module: seat booking with hold expiry and payment timeout, naive vs pessimistic vs optimistic inventories, race and deadlock demos, JDBC strategies on H2 (8 test classes, 8 transcripts)
Co-Authored-By: Claude Sonnet 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_017ic4b5YFRisPHrLBR2dRu9
This commit is contained in:
co-authored by
Claude Sonnet 5.5
parent
deb924febd
commit
c57031aaeb
@@ -0,0 +1,62 @@
|
||||
# bookmyshow
|
||||
|
||||
Companion code for the ankurm.com article **Low-Level Design: BookMyShow Seat Booking in Java (Handling Concurrent Bookings)**.
|
||||
|
||||
A seat-booking core with hold expiry and payment timeout, built three ways: a naive inventory that double-books,
|
||||
a pessimistic one (per-seat locks) and an optimistic one (compare-and-set). Every figure and console line in the
|
||||
article is quoted from a file in `output/`, which the JUnit tests write while asserting the same numbers. There is no
|
||||
`docs/` folder: the explanations live in the article itself.
|
||||
|
||||
## Versions
|
||||
|
||||
| Component | Version | Verified against |
|
||||
|---|---|---|
|
||||
| JDK | Temurin 25.0.5+8 (LTS) | `java -version` |
|
||||
| JUnit | 6.1.3 | `junit-bom` `maven-metadata.xml` on Maven Central (latest GA; `6.2.0-M1` is a milestone) |
|
||||
| H2 (tests only) | 2.5.252 | `com.h2database:h2` `maven-metadata.xml` on Maven Central |
|
||||
| Maven | 3.9.11 | `mvn -version` |
|
||||
|
||||
## Quickstart
|
||||
|
||||
```bash
|
||||
cd bookmyshow
|
||||
export JAVA_HOME=/path/to/jdk-25 PATH="$JAVA_HOME/bin:$PATH"
|
||||
./scripts/run-all.sh # runs every test and regenerates output/*.txt
|
||||
```
|
||||
|
||||
The first Maven run must be online so the plugins land in the local cache. Three transcripts contain counts that
|
||||
depend on thread timing (marked "control" or "timing dependent" inside the file); they differ from run to run by design.
|
||||
|
||||
## The pieces
|
||||
|
||||
| Class | Role |
|
||||
|---|---|
|
||||
| `Show`, `Seat`, `SeatCategory` | the screening and its seats; price depends on the seat category |
|
||||
| `SeatSlot`, `SeatState` | one seat's whole state as an immutable value: state, owner, expiry, version |
|
||||
| `SeatInventory` | the one interface where seat state changes: `tryHold`, `confirm`, `release` |
|
||||
| `NaiveInventory` | check-then-act on a `ConcurrentHashMap`; double-books |
|
||||
| `PessimisticInventory` | one `ReentrantLock` per seat, locks taken in sorted order |
|
||||
| `OptimisticInventory` | `AtomicReference<SeatSlot>` per seat, compare-and-set, roll back on conflict |
|
||||
| `JdbcSeatStore` | the same question in SQL: optimistic version column, `FOR UPDATE`, one conditional `UPDATE` |
|
||||
| `BookingService` | hold, pay, confirm; refund when the hold is lost during payment |
|
||||
| `MutableClock`, `FakePaymentGateway` | deterministic time and a payment provider the tests can slow down |
|
||||
|
||||
## The transcripts
|
||||
|
||||
| File | Written by | What it shows |
|
||||
|---|---|---|
|
||||
| `output/01-happy-path.txt` | `HappyPathTest` | one user at a time: all three inventories behave identically |
|
||||
| `output/02-naive-race.txt` | `RaceConditionTest` | the naive inventory granting one seat twice |
|
||||
| `output/03-lock-ordering.txt` | `LockOrderingTest` | deadlock with unsorted locks, mutual refusal with unsorted optimistic holds |
|
||||
| `output/04-contention.txt` | `ContentionTest` | 200 threads, one seat (timing dependent control line) |
|
||||
| `output/05-random-seats.txt` | `ContentionTest` | 400 users, random seats, invariants that must hold |
|
||||
| `output/06-expiry-and-payment.txt` | `ExpiryAndPaymentTest` | hold expiry, slow payment, resold seat, declined card |
|
||||
| `output/07-pitfalls.txt` | `PitfallsTest` | partial holds, foreign releases, bad input, double Pay |
|
||||
| `output/08-database-strategies.txt` | `DatabaseSeatTest` | the same race against H2 (timing dependent control line) |
|
||||
|
||||
`SeatInventory` implementations expose small test seams (`betweenCheckAndAct`, `afterFirstLock`, `afterFirstAcquire`,
|
||||
`beforeRollback`) so the tests can force an interleaving on every run. They are test hooks, not part of the design.
|
||||
|
||||
## License
|
||||
|
||||
MIT, see the repository root.
|
||||
@@ -0,0 +1,14 @@
|
||||
Happy path, one user at a time (show SH-1, 60 seats, hold TTL 5 minutes)
|
||||
========================================================================
|
||||
|
||||
A1 at the start: AVAILABLE v0
|
||||
startBooking(asha, A1+A2): BK-0001 PENDING_PAYMENT, Rs 440
|
||||
A1 after the hold: HELD by BK-0001 until T+05:00 v1
|
||||
A3 untouched: AVAILABLE v0
|
||||
startBooking(ravi, A2+A3): refused (seats not available for show SH-1: [A2, A3])
|
||||
A3 after ravi's refusal: AVAILABLE v0
|
||||
pay(BK-0001): CONFIRMED, booking is CONFIRMED
|
||||
A1 after payment: BOOKED by BK-0001 v2
|
||||
seat summary: {AVAILABLE=58, BOOKED=2, HELD=0}
|
||||
|
||||
Same log produced by NaiveInventory, PessimisticInventory and OptimisticInventory: true
|
||||
@@ -0,0 +1,20 @@
|
||||
NaiveInventory: two users request seat C5 at the same moment (barrier forces both reads before either write)
|
||||
====================================================================================================
|
||||
|
||||
holds granted for C5: 2 (a seat can only be sold once)
|
||||
both users now pay:
|
||||
outcomes (sorted): [CONFIRMED, HOLD_LOST_AFTER_PAYMENT]
|
||||
customers charged: 2
|
||||
customers refunded: 1
|
||||
C5 in the end: BOOKED by BK-000x v3
|
||||
|
||||
Neither thread did anything unusual. Each ran check, then act, and the barrier only decided
|
||||
that both checks finished before either act began.
|
||||
|
||||
PessimisticInventory, same two users at the same moment:
|
||||
holds granted for C5: 1
|
||||
loser sees: SeatUnavailableException
|
||||
|
||||
OptimisticInventory, same two users at the same moment:
|
||||
holds granted for C5: 1
|
||||
loser sees: SeatUnavailableException
|
||||
@@ -0,0 +1,21 @@
|
||||
Two requests for the same two seats, listed in opposite order: H1 asks [A1, A2], H2 asks [A2, A1]
|
||||
=================================================================================================
|
||||
|
||||
PessimisticInventory, AS_REQUESTED (each thread holds one lock, then waits for the other's):
|
||||
stuck until a lock wait timed out (300 ms): true
|
||||
at least one lock wait timed out: true
|
||||
requests that succeeded: at most 1 (never both; which one is timing dependent)
|
||||
Without the timeout both threads would wait forever.
|
||||
|
||||
PessimisticInventory, SORTED (both requests lock A1 first, so one simply waits):
|
||||
requests that succeeded: 1 of 2
|
||||
lock waits that timed out: 0
|
||||
|
||||
OptimisticInventory, AS_REQUESTED (each request takes one seat, then finds the other taken):
|
||||
results: [false, false]
|
||||
A1 / A2 afterwards: AVAILABLE / AVAILABLE (versions v2 / v2: held, then handed back)
|
||||
Both seats are free and both customers were turned away.
|
||||
|
||||
OptimisticInventory, SORTED (both start at A1, so only one can get past the first seat):
|
||||
requests that succeeded: 1 of 2
|
||||
HELD seats afterwards: 2
|
||||
@@ -0,0 +1,8 @@
|
||||
200 threads released at once, all asking for seat D4, repeated 30 times per inventory
|
||||
=====================================================================================
|
||||
|
||||
PessimisticInventory: rounds with exactly one winner: 30 of 30
|
||||
OptimisticInventory: rounds with exactly one winner: 30 of 30
|
||||
|
||||
Control, not asserted and timing dependent: NaiveInventory, no barrier inside it:
|
||||
NaiveInventory: rounds with exactly one winner: 10 of 30
|
||||
@@ -0,0 +1,24 @@
|
||||
400 users, each asking for 1 to 3 random seats of a 60-seat show (seeded plan), all released at once
|
||||
====================================================================================================
|
||||
|
||||
seats requested in total (seeded, identical for every inventory): 800
|
||||
|
||||
PessimisticInventory, SORTED:
|
||||
no seat granted to two requests: true
|
||||
every granted request owns all of its seats: true
|
||||
HELD seats == seats of granted requests: true
|
||||
AVAILABLE + HELD == 60: true
|
||||
|
||||
OptimisticInventory, SORTED:
|
||||
no seat granted to two requests: true
|
||||
every granted request owns all of its seats: true
|
||||
HELD seats == seats of granted requests: true
|
||||
AVAILABLE + HELD == 60: true
|
||||
|
||||
OptimisticInventory, AS_REQUESTED:
|
||||
no seat granted to two requests: true
|
||||
every granted request owns all of its seats: true
|
||||
HELD seats == seats of granted requests: true
|
||||
AVAILABLE + HELD == 60: true
|
||||
|
||||
How many requests were granted differs from run to run (it depends on the interleaving) and is deliberately not printed.
|
||||
@@ -0,0 +1,22 @@
|
||||
Hold expiry and payment timeout on a fake clock (TTL 5 minutes, no sleeping)
|
||||
============================================================================
|
||||
|
||||
1. Pay one second before the deadline
|
||||
hold placed T+00:00, expires T+05:00, pay pressed T+04:59
|
||||
outcome: CONFIRMED charges: 1 refunds: 0
|
||||
2. The deadline passes while Asha is on the payment page (she holds B1 and B2)
|
||||
T+04:59 B1 reads as HELD
|
||||
T+05:00 B1 reads as AVAILABLE (stored slot still says HELD: expiry is lazy)
|
||||
T+05:01 Ravi asks for B1: BK-0002 PENDING_PAYMENT
|
||||
T+05:02 Asha presses Pay: HOLD_EXPIRED_BEFORE_PAYMENT charges: 0
|
||||
B1: HELD by BK-0002 until T+10:01 v2
|
||||
B2: AVAILABLE v2
|
||||
3. Pay pressed at T+04:59, the gateway takes two minutes, nobody else wants the seat
|
||||
outcome: HOLD_LOST_AFTER_PAYMENT charges: 1 refunds: [BK-0001] booking: REFUNDED
|
||||
4. Same slow payment, but Ravi takes B4 while the gateway is still working on Asha's charge
|
||||
outcome: HOLD_LOST_AFTER_PAYMENT charges: 1 refunds: [BK-0001] booking: REFUNDED
|
||||
B4: HELD by BK-0002 until T+11:59 v2
|
||||
5. The card is declined
|
||||
outcome: PAYMENT_DECLINED booking: PAYMENT_FAILED B5 now: AVAILABLE
|
||||
|
||||
Same log produced by all three inventories: true
|
||||
@@ -0,0 +1,29 @@
|
||||
Pitfalls: partial holds, foreign releases, bad input, double Pay
|
||||
================================================================
|
||||
|
||||
1. Request [A1, A2, A3] while someone else holds A3
|
||||
NaiveInventory result false A1 AVAILABLE v0 A2 AVAILABLE v0
|
||||
PessimisticInventory result false A1 AVAILABLE v0 A2 AVAILABLE v0
|
||||
OptimisticInventory result false A1 AVAILABLE v2 A2 AVAILABLE v2
|
||||
(v0 means the seat was never touched; v2 means it was held and handed back during the attempt)
|
||||
|
||||
2. Someone who does not own the hold tries to release or confirm it
|
||||
NaiveInventory after Ravi's release and confirm: C1 is HELD by ASHA, Ravi's confirm returned false
|
||||
PessimisticInventory after Ravi's release and confirm: C1 is HELD by ASHA, Ravi's confirm returned false
|
||||
OptimisticInventory after Ravi's release and confirm: C1 is HELD by ASHA, Ravi's confirm returned false
|
||||
|
||||
3. A BOOKED seat is not released by release(), even by its owner
|
||||
NaiveInventory C2 after owner's release: BOOKED, a new hold on it returns false
|
||||
PessimisticInventory C2 after owner's release: BOOKED, a new hold on it returns false
|
||||
OptimisticInventory C2 after owner's release: BOOKED, a new hold on it returns false
|
||||
|
||||
4. Bad input (identical for all three inventories)
|
||||
duplicate seat ids: IllegalArgumentException: duplicate seat id in request: A1
|
||||
unknown seat: IllegalArgumentException: unknown seat Z99 for show SH-1
|
||||
no seats at all: IllegalArgumentException: no seats requested
|
||||
unknown show: IllegalArgumentException: unknown show: SH-404
|
||||
|
||||
5. Pay pressed 50 times at once for the same booking
|
||||
calls that confirmed: 1
|
||||
calls refused with IllegalStateException: 49
|
||||
times the card was charged: 1
|
||||
@@ -0,0 +1,9 @@
|
||||
32 connections released at once, all holding seat D4 of SH-1, repeated 20 times per strategy (H2 2.5.252)
|
||||
====================================================================================================
|
||||
|
||||
optimistic (SELECT, then UPDATE ... WHERE version = ?): rounds with exactly one winner: 20 of 20
|
||||
pessimistic (SELECT ... FOR UPDATE, then UPDATE): rounds with exactly one winner: 20 of 20
|
||||
conditional (one UPDATE ... WHERE state = 'AVAILABLE'): rounds with exactly one winner: 20 of 20
|
||||
|
||||
Control, not asserted and timing dependent:
|
||||
naive (SELECT, then UPDATE with no version or lock): rounds with exactly one winner: 3 of 20
|
||||
@@ -0,0 +1,71 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<groupId>com.ankurm.interviewlab</groupId>
|
||||
<artifactId>bookmyshow</artifactId>
|
||||
<version>1.0.0</version>
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<name>java-interview-lab :: bookmyshow</name>
|
||||
<description>
|
||||
Runnable companion code for ankurm.com's "Low-Level Design: BookMyShow Seat Booking in Java" article: seat holds,
|
||||
naive vs pessimistic vs optimistic inventories, hold expiry, payment timeout and concurrency tests.
|
||||
</description>
|
||||
|
||||
<properties>
|
||||
<maven.compiler.release>25</maven.compiler.release>
|
||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||
<junit.version>6.1.3</junit.version>
|
||||
<h2.version>2.5.252</h2.version>
|
||||
</properties>
|
||||
|
||||
<dependencyManagement>
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.junit</groupId>
|
||||
<artifactId>junit-bom</artifactId>
|
||||
<version>${junit.version}</version>
|
||||
<type>pom</type>
|
||||
<scope>import</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
</dependencyManagement>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.junit.jupiter</groupId>
|
||||
<artifactId>junit-jupiter</artifactId>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>com.h2database</groupId>
|
||||
<artifactId>h2</artifactId>
|
||||
<version>${h2.version}</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.junit.platform</groupId>
|
||||
<artifactId>junit-platform-launcher</artifactId>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<version>3.14.0</version>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-surefire-plugin</artifactId>
|
||||
<version>3.6.0</version>
|
||||
<configuration>
|
||||
<argLine>-Xmx512m -Duser.timezone=UTC -Dfile.encoding=UTF-8</argLine>
|
||||
</configuration>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
</project>
|
||||
Executable
+9
@@ -0,0 +1,9 @@
|
||||
#!/usr/bin/env bash
|
||||
# Regenerates every file in output/. Needs JDK 25 and Maven. The first Maven run must be online.
|
||||
# Every file is written by a JUnit test that asserts the same numbers it prints, so the figures
|
||||
# in the article are assertions: they fail the build the moment they stop being true.
|
||||
set -euo pipefail
|
||||
cd "$(dirname "$0")/.."
|
||||
mkdir -p output
|
||||
mvn -B -q -T1 test
|
||||
echo "done:"; ls -1 output
|
||||
+72
@@ -0,0 +1,72 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Instant;
|
||||
import java.util.EnumMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
/** Show registry, argument validation and summary, shared so the three implementations differ only in how they synchronise. */
|
||||
public abstract class AbstractSeatInventory implements SeatInventory {
|
||||
protected final Clock clock;
|
||||
private final Map<String, Show> shows = new ConcurrentHashMap<>();
|
||||
|
||||
protected AbstractSeatInventory(Clock clock) {
|
||||
this.clock = clock;
|
||||
}
|
||||
|
||||
@Override
|
||||
public final void register(Show show) {
|
||||
shows.put(show.id(), show);
|
||||
onRegister(show);
|
||||
}
|
||||
|
||||
protected abstract void onRegister(Show show);
|
||||
|
||||
@Override
|
||||
public final Show show(String showId) {
|
||||
Show s = shows.get(showId);
|
||||
if (s == null) {
|
||||
throw new IllegalArgumentException("unknown show: " + showId);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
@Override
|
||||
public final Clock clock() {
|
||||
return clock;
|
||||
}
|
||||
|
||||
/** Rejects empty requests, unknown seats and duplicate seat ids before any state is touched. */
|
||||
protected final void validate(String showId, List<String> seatIds) {
|
||||
Show s = show(showId);
|
||||
if (seatIds.isEmpty()) {
|
||||
throw new IllegalArgumentException("no seats requested");
|
||||
}
|
||||
Set<String> seen = new HashSet<>();
|
||||
for (String id : seatIds) {
|
||||
if (!s.hasSeat(id)) {
|
||||
throw new IllegalArgumentException("unknown seat " + id + " for show " + showId);
|
||||
}
|
||||
if (!seen.add(id)) {
|
||||
throw new IllegalArgumentException("duplicate seat id in request: " + id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public final Map<SeatState, Long> summary(String showId) {
|
||||
Instant now = clock.instant();
|
||||
Map<SeatState, Long> counts = new EnumMap<>(SeatState.class);
|
||||
for (SeatState st : SeatState.values()) {
|
||||
counts.put(st, 0L);
|
||||
}
|
||||
for (String id : show(showId).seatIds()) {
|
||||
counts.merge(slot(showId, id).effectiveState(now), 1L, Long::sum);
|
||||
}
|
||||
return counts;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
/** In which order a multi-seat request touches its seats. It sounds like a detail; sections 5 and 6 show it is not. */
|
||||
public enum AcquireOrder {
|
||||
/** Sort the seat ids first, so every request walks the seats in the same global order. */
|
||||
SORTED,
|
||||
/** Walk the seats in whatever order the caller listed them. */
|
||||
AS_REQUESTED
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.util.List;
|
||||
|
||||
public record Booking(String id, String userId, String showId, List<String> seatIds, int amountRupees,
|
||||
Instant heldAt, Instant expiresAt, BookingStatus status) {
|
||||
|
||||
public Booking withStatus(BookingStatus s) {
|
||||
return new Booking(id, userId, showId, seatIds, amountRupees, heldAt, expiresAt, s);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
/** What {@link BookingService#pay} reports. Four of the five are different ways of not getting a ticket. */
|
||||
public enum BookingOutcome {
|
||||
CONFIRMED,
|
||||
/** Pay was pressed after the hold had expired. Nothing was charged. */
|
||||
HOLD_EXPIRED_BEFORE_PAYMENT,
|
||||
/** The gateway declined. The seats were released. Nothing was charged. */
|
||||
PAYMENT_DECLINED,
|
||||
/** The gateway charged the customer, but by then the hold was gone. The charge was refunded. */
|
||||
HOLD_LOST_AFTER_PAYMENT
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.atomic.AtomicLong;
|
||||
|
||||
/**
|
||||
* The customer-facing flow: hold seats, pay, confirm. It knows nothing about locks. All concurrency control that
|
||||
* decides who gets a seat is inside the {@link SeatInventory}; the only concurrency this class handles itself is
|
||||
* "the same booking being paid twice".
|
||||
*/
|
||||
public final class BookingService {
|
||||
private final SeatInventory inventory;
|
||||
private final Clock clock;
|
||||
private final PaymentGateway payments;
|
||||
private final Duration holdTtl;
|
||||
private final Map<String, Booking> bookings = new ConcurrentHashMap<>();
|
||||
private final AtomicLong sequence = new AtomicLong();
|
||||
|
||||
public BookingService(SeatInventory inventory, Clock clock, PaymentGateway payments, Duration holdTtl) {
|
||||
this.inventory = inventory;
|
||||
this.clock = clock;
|
||||
this.payments = payments;
|
||||
this.holdTtl = holdTtl;
|
||||
}
|
||||
|
||||
/** Step 1: put a time-limited hold on the seats. Throws {@link SeatUnavailableException} if any seat is taken. */
|
||||
public Booking startBooking(String userId, String showId, List<String> seatIds) {
|
||||
Show show = inventory.show(showId);
|
||||
String bookingId = "BK-%04d".formatted(sequence.incrementAndGet());
|
||||
if (!inventory.tryHold(showId, seatIds, bookingId, holdTtl)) {
|
||||
throw new SeatUnavailableException(showId, seatIds);
|
||||
}
|
||||
Instant now = clock.instant();
|
||||
Booking b = new Booking(bookingId, userId, showId, List.copyOf(seatIds), show.priceOf(seatIds),
|
||||
now, now.plus(holdTtl), BookingStatus.PENDING_PAYMENT);
|
||||
bookings.put(bookingId, b);
|
||||
return b;
|
||||
}
|
||||
|
||||
/** Step 2: charge and confirm. See {@link BookingOutcome} for the five ways this can end. */
|
||||
public BookingOutcome pay(String bookingId) {
|
||||
Booking b = transition(bookingId, BookingStatus.PENDING_PAYMENT, BookingStatus.PAYMENT_IN_PROGRESS);
|
||||
|
||||
if (!clock.instant().isBefore(b.expiresAt())) {
|
||||
inventory.release(b.showId(), b.seatIds(), b.id());
|
||||
set(bookingId, BookingStatus.EXPIRED);
|
||||
return BookingOutcome.HOLD_EXPIRED_BEFORE_PAYMENT;
|
||||
}
|
||||
|
||||
PaymentResult result = payments.charge(b.id(), b.amountRupees());
|
||||
if (!result.success()) {
|
||||
inventory.release(b.showId(), b.seatIds(), b.id());
|
||||
set(bookingId, BookingStatus.PAYMENT_FAILED);
|
||||
return BookingOutcome.PAYMENT_DECLINED;
|
||||
}
|
||||
|
||||
if (inventory.confirm(b.showId(), b.seatIds(), b.id())) {
|
||||
set(bookingId, BookingStatus.CONFIRMED);
|
||||
return BookingOutcome.CONFIRMED;
|
||||
}
|
||||
|
||||
payments.refund(b.id());
|
||||
set(bookingId, BookingStatus.REFUNDED);
|
||||
return BookingOutcome.HOLD_LOST_AFTER_PAYMENT;
|
||||
}
|
||||
|
||||
/** The customer walked away: free the seats now rather than waiting for the hold to expire. */
|
||||
public void cancel(String bookingId) {
|
||||
Booking b = transition(bookingId, BookingStatus.PENDING_PAYMENT, BookingStatus.CANCELLED);
|
||||
inventory.release(b.showId(), b.seatIds(), b.id());
|
||||
}
|
||||
|
||||
public Booking booking(String bookingId) {
|
||||
Booking b = bookings.get(bookingId);
|
||||
if (b == null) {
|
||||
throw new IllegalArgumentException("unknown booking: " + bookingId);
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
/** Atomically moves a booking from one status to another, or throws if it was not in the expected status. */
|
||||
private Booking transition(String bookingId, BookingStatus from, BookingStatus to) {
|
||||
while (true) {
|
||||
Booking cur = booking(bookingId);
|
||||
if (cur.status() != from) {
|
||||
throw new IllegalStateException("booking " + bookingId + " is " + cur.status() + ", expected " + from);
|
||||
}
|
||||
Booking next = cur.withStatus(to);
|
||||
if (bookings.replace(bookingId, cur, next)) {
|
||||
return next;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void set(String bookingId, BookingStatus status) {
|
||||
bookings.computeIfPresent(bookingId, (k, v) -> v.withStatus(status));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
public enum BookingStatus {
|
||||
/** Seats are held; the customer has not pressed Pay yet. */
|
||||
PENDING_PAYMENT,
|
||||
/** Pay was pressed and the gateway is working. A second Pay for the same booking is refused while in this state. */
|
||||
PAYMENT_IN_PROGRESS,
|
||||
CONFIRMED,
|
||||
/** The hold ran out before payment was attempted. */
|
||||
EXPIRED,
|
||||
PAYMENT_FAILED,
|
||||
/** The customer was charged but the seats could no longer be confirmed, so the money was returned. */
|
||||
REFUNDED,
|
||||
CANCELLED
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
/**
|
||||
* A payment gateway that does whatever the test tells it to. {@link #duringCharge(Runnable)} runs while a charge is
|
||||
* "in flight", which is how the tests make payment slow: the hook advances the fake clock, or lets another user
|
||||
* grab the seat, exactly when a real gateway would be waiting on the bank.
|
||||
*/
|
||||
public final class FakePaymentGateway implements PaymentGateway {
|
||||
private final AtomicInteger charges = new AtomicInteger();
|
||||
private final List<String> refunds = new CopyOnWriteArrayList<>();
|
||||
private final AtomicBoolean declineNext = new AtomicBoolean();
|
||||
private volatile Runnable duringCharge = () -> { };
|
||||
|
||||
public void declineNext() {
|
||||
declineNext.set(true);
|
||||
}
|
||||
|
||||
public void duringCharge(Runnable hook) {
|
||||
this.duringCharge = hook;
|
||||
}
|
||||
|
||||
public int charges() {
|
||||
return charges.get();
|
||||
}
|
||||
|
||||
public List<String> refunds() {
|
||||
return refunds;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PaymentResult charge(String bookingId, int amountRupees) {
|
||||
charges.incrementAndGet();
|
||||
duringCharge.run();
|
||||
if (declineNext.getAndSet(false)) {
|
||||
return new PaymentResult(false, null);
|
||||
}
|
||||
return new PaymentResult(true, "PAY-" + bookingId);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void refund(String bookingId) {
|
||||
refunds.add(bookingId);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import javax.sql.DataSource;
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.sql.Timestamp;
|
||||
import java.time.Instant;
|
||||
|
||||
/**
|
||||
* The same seat, held three ways, with a database as the shared state instead of the JVM. This is what the in-memory
|
||||
* inventories turn into the moment the application runs on more than one server: a JVM lock or an
|
||||
* {@code AtomicReference} cannot be seen by the other server, but a row can.
|
||||
*
|
||||
* <p>One seat only, on purpose: the point is how each strategy decides who wins, not a complete schema.
|
||||
*/
|
||||
public final class JdbcSeatStore {
|
||||
private final DataSource dataSource;
|
||||
|
||||
public JdbcSeatStore(DataSource dataSource) {
|
||||
this.dataSource = dataSource;
|
||||
}
|
||||
|
||||
public void createSchema() throws SQLException {
|
||||
try (Connection c = dataSource.getConnection(); Statement s = c.createStatement()) {
|
||||
s.execute("""
|
||||
CREATE TABLE IF NOT EXISTS seat (
|
||||
show_id VARCHAR(20) NOT NULL,
|
||||
seat_id VARCHAR(10) NOT NULL,
|
||||
state VARCHAR(10) NOT NULL,
|
||||
hold_id VARCHAR(40),
|
||||
expires_at TIMESTAMP,
|
||||
version BIGINT NOT NULL,
|
||||
PRIMARY KEY (show_id, seat_id)
|
||||
)""");
|
||||
}
|
||||
}
|
||||
|
||||
public void resetSeat(String showId, String seatId) throws SQLException {
|
||||
try (Connection c = dataSource.getConnection(); Statement s = c.createStatement()) {
|
||||
s.execute("DELETE FROM seat WHERE show_id = '" + showId + "' AND seat_id = '" + seatId + "'");
|
||||
s.execute("INSERT INTO seat VALUES ('" + showId + "', '" + seatId + "', 'AVAILABLE', NULL, NULL, 0)");
|
||||
}
|
||||
}
|
||||
|
||||
/** The control: read the row, decide, then update with no version and no lock. This is check-then-act, in SQL. */
|
||||
public boolean holdNaive(String showId, String seatId, String holdId, Instant now, Instant expiresAt) throws SQLException {
|
||||
try (Connection c = dataSource.getConnection()) {
|
||||
try (PreparedStatement read = c.prepareStatement(
|
||||
"SELECT state, expires_at FROM seat WHERE show_id = ? AND seat_id = ?")) {
|
||||
read.setString(1, showId);
|
||||
read.setString(2, seatId);
|
||||
try (ResultSet rs = read.executeQuery()) {
|
||||
rs.next();
|
||||
if (!isFree(rs.getString("state"), rs.getTimestamp("expires_at"), now)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
try (PreparedStatement write = c.prepareStatement("""
|
||||
UPDATE seat SET state = 'HELD', hold_id = ?, expires_at = ?, version = version + 1
|
||||
WHERE show_id = ? AND seat_id = ?""")) {
|
||||
write.setString(1, holdId);
|
||||
write.setTimestamp(2, Timestamp.from(expiresAt));
|
||||
write.setString(3, showId);
|
||||
write.setString(4, seatId);
|
||||
return write.executeUpdate() == 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Strategy 1, optimistic: read the row and its version, then update only if the version is still the one we read. */
|
||||
public boolean holdOptimistic(String showId, String seatId, String holdId, Instant now, Instant expiresAt) throws SQLException {
|
||||
try (Connection c = dataSource.getConnection()) {
|
||||
long version;
|
||||
try (PreparedStatement read = c.prepareStatement(
|
||||
"SELECT state, expires_at, version FROM seat WHERE show_id = ? AND seat_id = ?")) {
|
||||
read.setString(1, showId);
|
||||
read.setString(2, seatId);
|
||||
try (ResultSet rs = read.executeQuery()) {
|
||||
rs.next();
|
||||
if (!isFree(rs.getString("state"), rs.getTimestamp("expires_at"), now)) {
|
||||
return false;
|
||||
}
|
||||
version = rs.getLong("version");
|
||||
}
|
||||
}
|
||||
try (PreparedStatement write = c.prepareStatement("""
|
||||
UPDATE seat SET state = 'HELD', hold_id = ?, expires_at = ?, version = version + 1
|
||||
WHERE show_id = ? AND seat_id = ? AND version = ?""")) {
|
||||
write.setString(1, holdId);
|
||||
write.setTimestamp(2, Timestamp.from(expiresAt));
|
||||
write.setString(3, showId);
|
||||
write.setString(4, seatId);
|
||||
write.setLong(5, version);
|
||||
return write.executeUpdate() == 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Strategy 2, pessimistic: lock the row with SELECT ... FOR UPDATE, decide while holding the lock, update, commit. */
|
||||
public boolean holdPessimistic(String showId, String seatId, String holdId, Instant now, Instant expiresAt) throws SQLException {
|
||||
try (Connection c = dataSource.getConnection()) {
|
||||
c.setAutoCommit(false);
|
||||
try {
|
||||
try (PreparedStatement lock = c.prepareStatement(
|
||||
"SELECT state, expires_at FROM seat WHERE show_id = ? AND seat_id = ? FOR UPDATE")) {
|
||||
lock.setString(1, showId);
|
||||
lock.setString(2, seatId);
|
||||
try (ResultSet rs = lock.executeQuery()) {
|
||||
rs.next();
|
||||
if (!isFree(rs.getString("state"), rs.getTimestamp("expires_at"), now)) {
|
||||
c.rollback();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
try (PreparedStatement write = c.prepareStatement("""
|
||||
UPDATE seat SET state = 'HELD', hold_id = ?, expires_at = ?, version = version + 1
|
||||
WHERE show_id = ? AND seat_id = ?""")) {
|
||||
write.setString(1, holdId);
|
||||
write.setTimestamp(2, Timestamp.from(expiresAt));
|
||||
write.setString(3, showId);
|
||||
write.setString(4, seatId);
|
||||
write.executeUpdate();
|
||||
}
|
||||
c.commit();
|
||||
return true;
|
||||
} catch (SQLException e) {
|
||||
c.rollback();
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Strategy 3, one conditional UPDATE: the "check" is the WHERE clause, so there is no gap between check and act. */
|
||||
public boolean holdConditionalUpdate(String showId, String seatId, String holdId, Instant now, Instant expiresAt) throws SQLException {
|
||||
try (Connection c = dataSource.getConnection();
|
||||
PreparedStatement write = c.prepareStatement("""
|
||||
UPDATE seat SET state = 'HELD', hold_id = ?, expires_at = ?, version = version + 1
|
||||
WHERE show_id = ? AND seat_id = ?
|
||||
AND (state = 'AVAILABLE' OR (state = 'HELD' AND expires_at <= ?))""")) {
|
||||
write.setString(1, holdId);
|
||||
write.setTimestamp(2, Timestamp.from(expiresAt));
|
||||
write.setString(3, showId);
|
||||
write.setString(4, seatId);
|
||||
write.setTimestamp(5, Timestamp.from(now));
|
||||
return write.executeUpdate() == 1;
|
||||
}
|
||||
}
|
||||
|
||||
public String stateOf(String showId, String seatId) throws SQLException {
|
||||
try (Connection c = dataSource.getConnection();
|
||||
PreparedStatement q = c.prepareStatement("SELECT state, hold_id, version FROM seat WHERE show_id = ? AND seat_id = ?")) {
|
||||
q.setString(1, showId);
|
||||
q.setString(2, seatId);
|
||||
try (ResultSet rs = q.executeQuery()) {
|
||||
rs.next();
|
||||
return rs.getString("state") + " by " + rs.getString("hold_id") + " v" + rs.getLong("version");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean isFree(String state, Timestamp expiresAt, Instant now) {
|
||||
return state.equals("AVAILABLE") || (state.equals("HELD") && !now.isBefore(expiresAt.toInstant()));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneId;
|
||||
import java.time.ZoneOffset;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
/**
|
||||
* A clock that only moves when told to. Hold expiry is the part of this design that depends on time, and a test that
|
||||
* calls {@code Thread.sleep(300000)} to wait out a five-minute hold is not a test anyone runs.
|
||||
*/
|
||||
public final class MutableClock extends Clock {
|
||||
private final AtomicReference<Instant> now;
|
||||
|
||||
public MutableClock(Instant start) {
|
||||
this.now = new AtomicReference<>(start);
|
||||
}
|
||||
|
||||
public void advance(Duration d) {
|
||||
now.updateAndGet(i -> i.plus(d));
|
||||
}
|
||||
|
||||
@Override
|
||||
public Instant instant() {
|
||||
return now.get();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ZoneId getZone() {
|
||||
return ZoneOffset.UTC;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Clock withZone(ZoneId zone) {
|
||||
return this;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
/**
|
||||
* The version everyone writes first, and the reason this article exists.
|
||||
*
|
||||
* <p>It uses a {@link ConcurrentHashMap}, so no map operation can corrupt the map. It is still wrong: tryHold
|
||||
* <em>reads</em> every seat, decides, and only then <em>writes</em>. Two threads can both read AVAILABLE before either
|
||||
* writes. A thread-safe collection does not make a check-then-act sequence safe.
|
||||
*
|
||||
* <p>The {@link #betweenCheckAndAct(Runnable)} hook is a test seam. It runs exactly in the gap between the check and the
|
||||
* act, which lets the tests make the race happen on every run instead of once in a few thousand.
|
||||
*/
|
||||
public final class NaiveInventory extends AbstractSeatInventory {
|
||||
private final Map<String, Map<String, SeatSlot>> slots = new ConcurrentHashMap<>();
|
||||
private volatile Runnable gap = () -> { };
|
||||
|
||||
public NaiveInventory(Clock clock) {
|
||||
super(clock);
|
||||
}
|
||||
|
||||
public void betweenCheckAndAct(Runnable hook) {
|
||||
this.gap = hook;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onRegister(Show show) {
|
||||
Map<String, SeatSlot> m = new ConcurrentHashMap<>();
|
||||
show.seatIds().forEach(id -> m.put(id, SeatSlot.initial()));
|
||||
slots.put(show.id(), m);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean tryHold(String showId, List<String> seatIds, String holdId, Duration ttl) {
|
||||
validate(showId, seatIds);
|
||||
Map<String, SeatSlot> m = slots.get(showId);
|
||||
Instant now = clock.instant();
|
||||
for (String id : seatIds) { // CHECK
|
||||
if (m.get(id).effectiveState(now) != SeatState.AVAILABLE) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
gap.run(); // <- another thread can act here
|
||||
Instant expiresAt = now.plus(ttl);
|
||||
for (String id : seatIds) { // ACT
|
||||
m.put(id, m.get(id).held(holdId, expiresAt));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean confirm(String showId, List<String> seatIds, String holdId) {
|
||||
validate(showId, seatIds);
|
||||
Map<String, SeatSlot> m = slots.get(showId);
|
||||
Instant now = clock.instant();
|
||||
for (String id : seatIds) {
|
||||
if (!m.get(id).isHeldBy(holdId, now)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
for (String id : seatIds) {
|
||||
m.put(id, m.get(id).booked());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void release(String showId, List<String> seatIds, String holdId) {
|
||||
validate(showId, seatIds);
|
||||
Map<String, SeatSlot> m = slots.get(showId);
|
||||
for (String id : seatIds) {
|
||||
if (m.get(id).ownsHold(holdId)) {
|
||||
m.put(id, m.get(id).released());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public SeatSlot slot(String showId, String seatId) {
|
||||
return slots.get(showId).get(seatId);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
/**
|
||||
* "Look, then change it only if nobody else did." No locks at all. Each seat is an {@link AtomicReference} to an
|
||||
* immutable {@link SeatSlot}; taking a seat is {@code compareAndSet(whatIRead, whatIWant)}, which succeeds only if the
|
||||
* slot is still exactly the object this thread read. That is the in-memory version of
|
||||
* {@code UPDATE seat SET ... WHERE id = ? AND version = ?}.
|
||||
*
|
||||
* <p>A multi-seat hold takes the seats one by one. If a later seat is taken, the earlier ones are handed back (also with
|
||||
* compare-and-set, so only our own holds are undone). That brief "taken then handed back" window is the price of not locking:
|
||||
* another request can be refused because of a hold that is about to be rolled back. {@link AcquireOrder} shows how much
|
||||
* this matters.
|
||||
*/
|
||||
public final class OptimisticInventory extends AbstractSeatInventory {
|
||||
private final Map<String, Map<String, AtomicReference<SeatSlot>>> refs = new ConcurrentHashMap<>();
|
||||
private final AcquireOrder order;
|
||||
private final AtomicInteger casRetries = new AtomicInteger();
|
||||
private volatile Runnable afterFirstAcquire = () -> { };
|
||||
private volatile Runnable beforeRollback = () -> { };
|
||||
|
||||
public OptimisticInventory(Clock clock) {
|
||||
this(clock, AcquireOrder.SORTED);
|
||||
}
|
||||
|
||||
public OptimisticInventory(Clock clock, AcquireOrder order) {
|
||||
super(clock);
|
||||
this.order = order;
|
||||
}
|
||||
|
||||
/** Test seam: runs once a request has taken its first seat and before it reaches for the second. */
|
||||
public void afterFirstAcquire(Runnable hook) {
|
||||
this.afterFirstAcquire = hook;
|
||||
}
|
||||
|
||||
/** Test seam: runs when a request has found a seat taken and is about to hand back the seats it already holds. */
|
||||
public void beforeRollback(Runnable hook) {
|
||||
this.beforeRollback = hook;
|
||||
}
|
||||
|
||||
/** How many times a compare-and-set lost to a concurrent change and the seat was re-read. Timing dependent. */
|
||||
public int casRetries() {
|
||||
return casRetries.get();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onRegister(Show show) {
|
||||
Map<String, AtomicReference<SeatSlot>> m = new ConcurrentHashMap<>();
|
||||
show.seatIds().forEach(id -> m.put(id, new AtomicReference<>(SeatSlot.initial())));
|
||||
refs.put(show.id(), m);
|
||||
}
|
||||
|
||||
private List<String> ordered(List<String> seatIds) {
|
||||
List<String> ids = new ArrayList<>(seatIds);
|
||||
if (order == AcquireOrder.SORTED) {
|
||||
Collections.sort(ids);
|
||||
}
|
||||
return ids;
|
||||
}
|
||||
|
||||
/** A seat this request has taken, with the exact slot it installed, so that rollback can undo precisely that. */
|
||||
private record Taken(AtomicReference<SeatSlot> ref, SeatSlot installed) { }
|
||||
|
||||
@Override
|
||||
public boolean tryHold(String showId, List<String> seatIds, String holdId, Duration ttl) {
|
||||
validate(showId, seatIds);
|
||||
Instant now = clock.instant();
|
||||
Instant expiresAt = now.plus(ttl);
|
||||
List<Taken> taken = new ArrayList<>();
|
||||
for (String id : ordered(seatIds)) {
|
||||
AtomicReference<SeatSlot> ref = refs.get(showId).get(id);
|
||||
boolean got = false;
|
||||
while (true) {
|
||||
SeatSlot seen = ref.get(); // LOOK
|
||||
if (seen.effectiveState(now) != SeatState.AVAILABLE) {
|
||||
break; // genuinely taken: give up
|
||||
}
|
||||
SeatSlot wanted = seen.held(holdId, expiresAt);
|
||||
if (ref.compareAndSet(seen, wanted)) { // CHANGE, only if unchanged
|
||||
taken.add(new Taken(ref, wanted));
|
||||
got = true;
|
||||
break;
|
||||
}
|
||||
casRetries.incrementAndGet(); // somebody else moved first: look again
|
||||
}
|
||||
if (!got) {
|
||||
beforeRollback.run();
|
||||
rollback(taken, SeatSlot::released);
|
||||
return false;
|
||||
}
|
||||
if (taken.size() == 1) {
|
||||
afterFirstAcquire.run();
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private static void rollback(List<Taken> taken, java.util.function.UnaryOperator<SeatSlot> undo) {
|
||||
for (Taken t : taken) {
|
||||
t.ref().compareAndSet(t.installed(), undo.apply(t.installed()));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean confirm(String showId, List<String> seatIds, String holdId) {
|
||||
validate(showId, seatIds);
|
||||
Instant now = clock.instant();
|
||||
List<Taken> booked = new ArrayList<>();
|
||||
for (String id : ordered(seatIds)) {
|
||||
AtomicReference<SeatSlot> ref = refs.get(showId).get(id);
|
||||
SeatSlot seen = ref.get();
|
||||
SeatSlot wanted = seen.booked();
|
||||
if (!seen.isHeldBy(holdId, now) || !ref.compareAndSet(seen, wanted)) {
|
||||
rollback(booked, SeatSlot::released); // we own these seats, so freeing them is correct: the booking failed
|
||||
return false;
|
||||
}
|
||||
booked.add(new Taken(ref, wanted));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void release(String showId, List<String> seatIds, String holdId) {
|
||||
validate(showId, seatIds);
|
||||
for (String id : seatIds) {
|
||||
AtomicReference<SeatSlot> ref = refs.get(showId).get(id);
|
||||
while (true) {
|
||||
SeatSlot seen = ref.get();
|
||||
if (!seen.ownsHold(holdId) || ref.compareAndSet(seen, seen.released())) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public SeatSlot slot(String showId, String seatId) {
|
||||
return refs.get(showId).get(seatId).get();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
/** The only thing the booking flow needs from a payment provider. Real gateways add idempotency keys and webhooks; see the article. */
|
||||
public interface PaymentGateway {
|
||||
PaymentResult charge(String bookingId, int amountRupees);
|
||||
|
||||
void refund(String bookingId);
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
public record PaymentResult(boolean success, String reference) { }
|
||||
+186
@@ -0,0 +1,186 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
|
||||
/**
|
||||
* "Lock before you look." Every seat has its own lock; a request takes the locks of all its seats, checks them all,
|
||||
* writes them all, and unlocks. While it holds the locks nobody else can read-then-write the same seats, so the
|
||||
* check-then-act gap of {@link NaiveInventory} is closed.
|
||||
*
|
||||
* <p>Taking several locks introduces a new failure: deadlock. {@link AcquireOrder#SORTED} prevents it by making every
|
||||
* request lock in the same global order. {@link AcquireOrder#AS_REQUESTED} exists so the tests can show the deadlock;
|
||||
* it uses {@code tryLock} with a timeout so that a demonstration ends instead of hanging, and counts how often that
|
||||
* happened in {@link #lockTimeouts()}.
|
||||
*/
|
||||
public final class PessimisticInventory extends AbstractSeatInventory {
|
||||
|
||||
/** A seat plus its lock. {@code slot} is only read or written while {@code lock} is held. */
|
||||
private static final class Cell {
|
||||
final ReentrantLock lock = new ReentrantLock();
|
||||
SeatSlot slot = SeatSlot.initial();
|
||||
}
|
||||
|
||||
private final Map<String, Map<String, Cell>> cells = new ConcurrentHashMap<>();
|
||||
private final AcquireOrder order;
|
||||
private final Duration lockWait;
|
||||
private final AtomicInteger lockTimeouts = new AtomicInteger();
|
||||
private volatile Runnable afterFirstLock = () -> { };
|
||||
|
||||
public PessimisticInventory(Clock clock) {
|
||||
this(clock, AcquireOrder.SORTED, Duration.ofSeconds(5));
|
||||
}
|
||||
|
||||
public PessimisticInventory(Clock clock, AcquireOrder order, Duration lockWait) {
|
||||
super(clock);
|
||||
this.order = order;
|
||||
this.lockWait = lockWait;
|
||||
}
|
||||
|
||||
/** Test seam: runs once a request holds its first lock and before it asks for the second. */
|
||||
public void afterFirstLock(Runnable hook) {
|
||||
this.afterFirstLock = hook;
|
||||
}
|
||||
|
||||
public int lockTimeouts() {
|
||||
return lockTimeouts.get();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onRegister(Show show) {
|
||||
Map<String, Cell> m = new ConcurrentHashMap<>();
|
||||
show.seatIds().forEach(id -> m.put(id, new Cell()));
|
||||
cells.put(show.id(), m);
|
||||
}
|
||||
|
||||
/** Locks the cells in the configured order; returns null (holding nothing) if a lock could not be had in time. */
|
||||
private List<Cell> lockAll(String showId, List<String> seatIds) throws InterruptedException {
|
||||
List<String> ids = new ArrayList<>(seatIds);
|
||||
if (order == AcquireOrder.SORTED) {
|
||||
Collections.sort(ids);
|
||||
}
|
||||
List<Cell> locked = new ArrayList<>();
|
||||
for (String id : ids) {
|
||||
Cell c = cells.get(showId).get(id);
|
||||
if (!c.lock.tryLock(lockWait.toMillis(), TimeUnit.MILLISECONDS)) {
|
||||
lockTimeouts.incrementAndGet();
|
||||
unlockAll(locked);
|
||||
return null;
|
||||
}
|
||||
locked.add(c);
|
||||
if (locked.size() == 1) {
|
||||
afterFirstLock.run();
|
||||
}
|
||||
}
|
||||
return locked;
|
||||
}
|
||||
|
||||
private static void unlockAll(List<Cell> locked) {
|
||||
for (Cell c : locked) {
|
||||
c.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean tryHold(String showId, List<String> seatIds, String holdId, Duration ttl) {
|
||||
validate(showId, seatIds);
|
||||
List<Cell> locked;
|
||||
try {
|
||||
locked = lockAll(showId, seatIds);
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
return false;
|
||||
}
|
||||
if (locked == null) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
Instant now = clock.instant();
|
||||
for (Cell c : locked) {
|
||||
if (c.slot.effectiveState(now) != SeatState.AVAILABLE) {
|
||||
return false; // nothing was written yet, so there is nothing to undo
|
||||
}
|
||||
}
|
||||
Instant expiresAt = now.plus(ttl);
|
||||
for (Cell c : locked) {
|
||||
c.slot = c.slot.held(holdId, expiresAt);
|
||||
}
|
||||
return true;
|
||||
} finally {
|
||||
unlockAll(locked);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean confirm(String showId, List<String> seatIds, String holdId) {
|
||||
validate(showId, seatIds);
|
||||
List<Cell> locked;
|
||||
try {
|
||||
locked = lockAll(showId, seatIds);
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
return false;
|
||||
}
|
||||
if (locked == null) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
Instant now = clock.instant();
|
||||
for (Cell c : locked) {
|
||||
if (!c.slot.isHeldBy(holdId, now)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
for (Cell c : locked) {
|
||||
c.slot = c.slot.booked();
|
||||
}
|
||||
return true;
|
||||
} finally {
|
||||
unlockAll(locked);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void release(String showId, List<String> seatIds, String holdId) {
|
||||
validate(showId, seatIds);
|
||||
List<Cell> locked;
|
||||
try {
|
||||
locked = lockAll(showId, seatIds);
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
return;
|
||||
}
|
||||
if (locked == null) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
for (Cell c : locked) {
|
||||
if (c.slot.ownsHold(holdId)) {
|
||||
c.slot = c.slot.released();
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
unlockAll(locked);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public SeatSlot slot(String showId, String seatId) {
|
||||
Cell c = cells.get(showId).get(seatId);
|
||||
c.lock.lock();
|
||||
try {
|
||||
return c.slot;
|
||||
} finally {
|
||||
c.lock.unlock();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
public record Seat(String id, SeatCategory category, int priceRupees) {}
|
||||
@@ -0,0 +1,3 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
public enum SeatCategory { REGULAR, PREMIUM, RECLINER }
|
||||
@@ -0,0 +1,47 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Owns the state of every seat of every registered show, and is the only place where seat state changes.
|
||||
* Everything concurrent about BookMyShow lives behind these methods; {@link BookingService} stays single-minded.
|
||||
*
|
||||
* <p>Contract shared by all implementations (pinned by the tests):
|
||||
* <ul>
|
||||
* <li>{@link #tryHold} is all-or-nothing: either every requested seat becomes HELD for {@code holdId}, or none changes
|
||||
* value that a reader could observe as "held".</li>
|
||||
* <li>Seat ids must be known to the show and distinct, otherwise {@link IllegalArgumentException}.</li>
|
||||
* <li>{@link #confirm} and {@link #release} only act on holds owned by {@code holdId}.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public interface SeatInventory {
|
||||
|
||||
void register(Show show);
|
||||
|
||||
Show show(String showId);
|
||||
|
||||
Clock clock();
|
||||
|
||||
/** Attempts to hold every seat for {@code holdId} for {@code ttl}. Returns false, changing nothing observable, if any seat is taken. */
|
||||
boolean tryHold(String showId, List<String> seatIds, String holdId, Duration ttl);
|
||||
|
||||
/** Turns {@code holdId}'s unexpired holds on all these seats into BOOKED. False (and nothing booked) if any hold is missing, expired or not owned. */
|
||||
boolean confirm(String showId, List<String> seatIds, String holdId);
|
||||
|
||||
/** Frees the seats that {@code holdId} still holds. Seats held by anyone else, or already booked, are left alone. */
|
||||
void release(String showId, List<String> seatIds, String holdId);
|
||||
|
||||
/** The raw slot, including a HELD value that may be past its expiry. */
|
||||
SeatSlot slot(String showId, String seatId);
|
||||
|
||||
/** The state a reader should believe right now, with expiry applied. */
|
||||
default SeatState stateOf(String showId, String seatId) {
|
||||
return slot(showId, seatId).effectiveState(clock().instant());
|
||||
}
|
||||
|
||||
/** Count of seats per effective state for one show. */
|
||||
Map<SeatState, Long> summary(String showId);
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Instant;
|
||||
|
||||
/**
|
||||
* The whole mutable truth about one seat of one show, as one immutable value.
|
||||
*
|
||||
* <p>Making it immutable is what lets {@link OptimisticInventory} use compare-and-set: "replace this exact
|
||||
* object with that one" is a complete, atomic description of a seat changing state. Every transition bumps
|
||||
* {@code version}, which is the same idea as the version column of a database row.
|
||||
*
|
||||
* @param state what the slot says. Note that a HELD slot whose time has passed is <em>effectively</em> available;
|
||||
* see {@link #effectiveState(Instant)}.
|
||||
* @param holdId who owns the hold or the booking (a booking id), null while AVAILABLE
|
||||
* @param expiresAt when a HELD slot stops counting, null otherwise
|
||||
* @param version number of transitions this seat has been through
|
||||
*/
|
||||
public record SeatSlot(SeatState state, String holdId, Instant expiresAt, long version) {
|
||||
|
||||
public static SeatSlot initial() {
|
||||
return new SeatSlot(SeatState.AVAILABLE, null, null, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* What a reader should believe at {@code now}. A hold is valid strictly before {@code expiresAt}; at the
|
||||
* expiry instant itself it is already gone. Expiry is lazy: nothing rewrites the slot, readers just do this check.
|
||||
*/
|
||||
public SeatState effectiveState(Instant now) {
|
||||
if (state == SeatState.HELD && !now.isBefore(expiresAt)) {
|
||||
return SeatState.AVAILABLE;
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
/** True when {@code holdId} owns a hold that has not expired at {@code now}. This is the check confirm() relies on. */
|
||||
public boolean isHeldBy(String holdId, Instant now) {
|
||||
return state == SeatState.HELD && this.holdId.equals(holdId) && now.isBefore(expiresAt);
|
||||
}
|
||||
|
||||
/** True when {@code holdId} wrote this hold, expired or not. release() uses this so it can never free someone else's seat. */
|
||||
public boolean ownsHold(String holdId) {
|
||||
return state == SeatState.HELD && this.holdId.equals(holdId);
|
||||
}
|
||||
|
||||
public SeatSlot held(String holdId, Instant expiresAt) {
|
||||
return new SeatSlot(SeatState.HELD, holdId, expiresAt, version + 1);
|
||||
}
|
||||
|
||||
public SeatSlot booked() {
|
||||
return new SeatSlot(SeatState.BOOKED, holdId, null, version + 1);
|
||||
}
|
||||
|
||||
public SeatSlot released() {
|
||||
return new SeatSlot(SeatState.AVAILABLE, null, null, version + 1);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
/** The three states a seat can be in for one show. A seat has no "locked" state: a lock is a way of changing state, not a state. */
|
||||
public enum SeatState {
|
||||
/** Nobody has a claim on the seat. */
|
||||
AVAILABLE,
|
||||
/** Someone is paying for it. The claim expires at {@link SeatSlot#expiresAt()}. */
|
||||
HELD,
|
||||
/** Paid for. Permanent for this module (cancellation of confirmed bookings is out of scope). */
|
||||
BOOKED
|
||||
}
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/** Thrown by {@link BookingService#startBooking} when at least one requested seat is held or booked by someone else. */
|
||||
public class SeatUnavailableException extends RuntimeException {
|
||||
public SeatUnavailableException(String showId, List<String> seatIds) {
|
||||
super("seats not available for show " + showId + ": " + seatIds);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/** One screening of one movie on one screen. Seats are fixed at construction; their state lives in a {@link SeatInventory}. */
|
||||
public final class Show {
|
||||
private final String id;
|
||||
private final String movie;
|
||||
private final String screen;
|
||||
private final Instant startsAt;
|
||||
private final Map<String, Seat> seatsById;
|
||||
private final List<String> orderedIds;
|
||||
|
||||
public Show(String id, String movie, String screen, Instant startsAt, List<Seat> seats) {
|
||||
this.id = id;
|
||||
this.movie = movie;
|
||||
this.screen = screen;
|
||||
this.startsAt = startsAt;
|
||||
Map<String, Seat> m = new LinkedHashMap<>();
|
||||
for (Seat s : seats) {
|
||||
m.put(s.id(), s);
|
||||
}
|
||||
this.seatsById = Map.copyOf(m);
|
||||
this.orderedIds = List.copyOf(m.keySet());
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds a rows x cols grid with ids A1..A10, B1..B10 and so on. The last row is RECLINER, the one before it
|
||||
* PREMIUM, everything above REGULAR, so a booking's price depends on which seats it contains.
|
||||
*/
|
||||
public static Show grid(String id, String movie, String screen, Instant startsAt, int rows, int cols) {
|
||||
if (rows < 3) {
|
||||
throw new IllegalArgumentException("need at least 3 rows");
|
||||
}
|
||||
List<Seat> seats = new java.util.ArrayList<>();
|
||||
for (int r = 0; r < rows; r++) {
|
||||
char letter = (char) ('A' + r);
|
||||
SeatCategory cat = r == rows - 1 ? SeatCategory.RECLINER : r == rows - 2 ? SeatCategory.PREMIUM : SeatCategory.REGULAR;
|
||||
int price = switch (cat) {
|
||||
case REGULAR -> 220;
|
||||
case PREMIUM -> 350;
|
||||
case RECLINER -> 600;
|
||||
};
|
||||
for (int c = 1; c <= cols; c++) {
|
||||
seats.add(new Seat("" + letter + c, cat, price));
|
||||
}
|
||||
}
|
||||
return new Show(id, movie, screen, startsAt, seats);
|
||||
}
|
||||
|
||||
public String id() { return id; }
|
||||
public String movie() { return movie; }
|
||||
public String screen() { return screen; }
|
||||
public Instant startsAt() { return startsAt; }
|
||||
public boolean hasSeat(String seatId) { return seatsById.containsKey(seatId); }
|
||||
public Seat seat(String seatId) { return seatsById.get(seatId); }
|
||||
/** Seat ids in construction order (row by row). */
|
||||
public List<String> seatIds() { return orderedIds; }
|
||||
|
||||
public int priceOf(List<String> seatIds) {
|
||||
int total = 0;
|
||||
for (String s : seatIds) {
|
||||
total += seat(s).priceRupees();
|
||||
}
|
||||
return total;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Fixtures;
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Transcript;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.Future;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import java.util.function.Supplier;
|
||||
|
||||
import static com.ankurm.interviewlab.bookmyshow.support.Fixtures.SHOW_ID;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/** Section 7: many threads, no barriers inside the inventories. What must stay true however the threads interleave. */
|
||||
class ContentionTest {
|
||||
private static final Duration TTL = Duration.ofMinutes(5);
|
||||
private static final int THREADS = 200;
|
||||
private static final int ROUNDS = 30;
|
||||
|
||||
/** Releases all tasks at once on platform threads (virtual threads mostly ran one after another on this 2-vCPU box) and returns when every one has finished. */
|
||||
private static void stampede(List<Runnable> tasks) throws Exception {
|
||||
CountDownLatch go = new CountDownLatch(1);
|
||||
try (ExecutorService pool = Executors.newThreadPerTaskExecutor(Thread.ofPlatform().name("stampede-", 0).factory())) {
|
||||
List<Future<?>> fs = new ArrayList<>();
|
||||
for (Runnable r : tasks) {
|
||||
fs.add(pool.submit(() -> {
|
||||
go.await();
|
||||
r.run();
|
||||
return null;
|
||||
}));
|
||||
}
|
||||
go.countDown();
|
||||
for (Future<?> f : fs) {
|
||||
f.get(60, TimeUnit.SECONDS);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Runs ROUNDS stampedes of THREADS threads at one seat; returns how many rounds ended with exactly one winner. */
|
||||
private static int roundsWithExactlyOneWinner(String inventoryName) throws Exception {
|
||||
int exactlyOne = 0;
|
||||
for (int round = 0; round < ROUNDS; round++) {
|
||||
SeatInventory inv = Fixtures.fresh(inventoryName, Fixtures.clock());
|
||||
AtomicInteger winners = new AtomicInteger();
|
||||
List<Runnable> tasks = new ArrayList<>();
|
||||
for (int i = 0; i < THREADS; i++) {
|
||||
String holdId = "H" + i;
|
||||
tasks.add(() -> {
|
||||
if (inv.tryHold(SHOW_ID, List.of("D4"), holdId, TTL)) {
|
||||
winners.incrementAndGet();
|
||||
}
|
||||
});
|
||||
}
|
||||
stampede(tasks);
|
||||
if (winners.get() == 1) {
|
||||
exactlyOne++;
|
||||
}
|
||||
}
|
||||
return exactlyOne;
|
||||
}
|
||||
|
||||
@Test
|
||||
void twoHundredThreadsOneSeat() throws Exception {
|
||||
Transcript t = Transcript.start("04-contention.txt",
|
||||
THREADS + " threads released at once, all asking for seat D4, repeated " + ROUNDS + " times per inventory");
|
||||
int pess = roundsWithExactlyOneWinner("PessimisticInventory");
|
||||
int opt = roundsWithExactlyOneWinner("OptimisticInventory");
|
||||
assertEquals(ROUNDS, pess);
|
||||
assertEquals(ROUNDS, opt);
|
||||
t.line("PessimisticInventory: rounds with exactly one winner: " + pess + " of " + ROUNDS);
|
||||
t.line("OptimisticInventory: rounds with exactly one winner: " + opt + " of " + ROUNDS);
|
||||
|
||||
int naive = roundsWithExactlyOneWinner("NaiveInventory");
|
||||
t.blank();
|
||||
t.line("Control, not asserted and timing dependent: NaiveInventory, no barrier inside it:");
|
||||
t.line("NaiveInventory: rounds with exactly one winner: " + naive + " of " + ROUNDS);
|
||||
t.flush();
|
||||
}
|
||||
|
||||
private record Request(String holdId, List<String> seats) { }
|
||||
|
||||
private static List<Request> plan(long seed, int requests, int maxSeats, List<String> seatIds) {
|
||||
Random rnd = new Random(seed);
|
||||
List<Request> plan = new ArrayList<>();
|
||||
for (int i = 0; i < requests; i++) {
|
||||
int n = 1 + rnd.nextInt(maxSeats);
|
||||
Set<String> pick = new java.util.LinkedHashSet<>();
|
||||
while (pick.size() < n) {
|
||||
pick.add(seatIds.get(rnd.nextInt(seatIds.size())));
|
||||
}
|
||||
plan.add(new Request("R" + i, List.copyOf(pick)));
|
||||
}
|
||||
return plan;
|
||||
}
|
||||
|
||||
@Test
|
||||
void manyUsersRandomSeatsKeepTheInvariants() throws Exception {
|
||||
List<String> seatIds = Fixtures.show().seatIds();
|
||||
List<Request> plan = plan(20261120L, 400, 3, seatIds);
|
||||
int seatsRequested = plan.stream().mapToInt(r -> r.seats().size()).sum();
|
||||
|
||||
Transcript t = Transcript.start("05-random-seats.txt",
|
||||
"400 users, each asking for 1 to 3 random seats of a 60-seat show (seeded plan), all released at once");
|
||||
t.line("seats requested in total (seeded, identical for every inventory): " + seatsRequested);
|
||||
|
||||
record Variant(String label, Supplier<SeatInventory> make) { }
|
||||
List<Variant> variants = List.of(
|
||||
new Variant("PessimisticInventory, SORTED", () -> {
|
||||
SeatInventory i = new PessimisticInventory(Fixtures.clock());
|
||||
i.register(Fixtures.show());
|
||||
return i;
|
||||
}),
|
||||
new Variant("OptimisticInventory, SORTED", () -> {
|
||||
SeatInventory i = new OptimisticInventory(Fixtures.clock(), AcquireOrder.SORTED);
|
||||
i.register(Fixtures.show());
|
||||
return i;
|
||||
}),
|
||||
new Variant("OptimisticInventory, AS_REQUESTED", () -> {
|
||||
SeatInventory i = new OptimisticInventory(Fixtures.clock(), AcquireOrder.AS_REQUESTED);
|
||||
i.register(Fixtures.show());
|
||||
return i;
|
||||
}));
|
||||
|
||||
for (Variant v : variants) {
|
||||
SeatInventory inv = v.make().get();
|
||||
List<Request> granted = java.util.Collections.synchronizedList(new ArrayList<>());
|
||||
List<Runnable> tasks = new ArrayList<>();
|
||||
for (Request r : plan) {
|
||||
tasks.add(() -> {
|
||||
if (inv.tryHold(SHOW_ID, r.seats(), r.holdId(), TTL)) {
|
||||
granted.add(r);
|
||||
}
|
||||
});
|
||||
}
|
||||
stampede(tasks);
|
||||
|
||||
Set<String> seen = new HashSet<>();
|
||||
boolean noSeatTwice = true;
|
||||
boolean ownsItsSeats = true;
|
||||
int grantedSeats = 0;
|
||||
for (Request r : granted) {
|
||||
for (String s : r.seats()) {
|
||||
noSeatTwice &= seen.add(s);
|
||||
SeatSlot slot = inv.slot(SHOW_ID, s);
|
||||
ownsItsSeats &= slot.state() == SeatState.HELD && slot.holdId().equals(r.holdId());
|
||||
grantedSeats++;
|
||||
}
|
||||
}
|
||||
long held = inv.summary(SHOW_ID).get(SeatState.HELD);
|
||||
long available = inv.summary(SHOW_ID).get(SeatState.AVAILABLE);
|
||||
assertTrue(noSeatTwice);
|
||||
assertTrue(ownsItsSeats);
|
||||
assertEquals(grantedSeats, held);
|
||||
assertEquals(60 - grantedSeats, available);
|
||||
assertTrue(!granted.isEmpty());
|
||||
|
||||
t.blank();
|
||||
t.line(v.label() + ":");
|
||||
t.line(" no seat granted to two requests: " + noSeatTwice);
|
||||
t.line(" every granted request owns all of its seats: " + ownsItsSeats);
|
||||
t.line(" HELD seats == seats of granted requests: " + (held == grantedSeats));
|
||||
t.line(" AVAILABLE + HELD == 60: " + (available + held == 60));
|
||||
}
|
||||
t.blank();
|
||||
t.line("How many requests were granted differs from run to run (it depends on the interleaving) and is deliberately not printed.");
|
||||
t.flush();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Transcript;
|
||||
import org.h2.jdbcx.JdbcDataSource;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
import static com.ankurm.interviewlab.bookmyshow.RaceConditionTest.runTogether;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
/** Section 10: the same three-way question against a real SQL database (H2 in memory, several connections). */
|
||||
class DatabaseSeatTest {
|
||||
private interface Hold {
|
||||
boolean run(JdbcSeatStore store, String holdId, Instant now, Instant exp) throws Exception;
|
||||
}
|
||||
|
||||
private static int roundsWithExactlyOneWinner(JdbcSeatStore store, Hold strategy, int threads, int rounds) throws Exception {
|
||||
int ok = 0;
|
||||
Instant now = Instant.parse("2026-11-20T10:00:00Z");
|
||||
Instant exp = now.plus(Duration.ofMinutes(5));
|
||||
for (int r = 0; r < rounds; r++) {
|
||||
store.resetSeat("SH-1", "D4");
|
||||
AtomicInteger winners = new AtomicInteger();
|
||||
List<Callable<Void>> tasks = new ArrayList<>();
|
||||
for (int i = 0; i < threads; i++) {
|
||||
String holdId = "H" + i;
|
||||
tasks.add(() -> {
|
||||
if (strategy.run(store, holdId, now, exp)) {
|
||||
winners.incrementAndGet();
|
||||
}
|
||||
return null;
|
||||
});
|
||||
}
|
||||
runTogether(tasks);
|
||||
if (winners.get() == 1) {
|
||||
ok++;
|
||||
}
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
@Test
|
||||
void sameSeatThreeSqlStrategies() throws Exception {
|
||||
JdbcDataSource ds = new JdbcDataSource();
|
||||
ds.setURL("jdbc:h2:mem:bookmyshow;DB_CLOSE_DELAY=-1");
|
||||
JdbcSeatStore store = new JdbcSeatStore(ds);
|
||||
store.createSchema();
|
||||
|
||||
int threads = 32;
|
||||
int rounds = 20;
|
||||
int optimistic = roundsWithExactlyOneWinner(store,
|
||||
(s, h, n, e) -> s.holdOptimistic("SH-1", "D4", h, n, e), threads, rounds);
|
||||
int pessimistic = roundsWithExactlyOneWinner(store,
|
||||
(s, h, n, e) -> s.holdPessimistic("SH-1", "D4", h, n, e), threads, rounds);
|
||||
int conditional = roundsWithExactlyOneWinner(store,
|
||||
(s, h, n, e) -> s.holdConditionalUpdate("SH-1", "D4", h, n, e), threads, rounds);
|
||||
assertEquals(rounds, optimistic);
|
||||
assertEquals(rounds, pessimistic);
|
||||
assertEquals(rounds, conditional);
|
||||
|
||||
Transcript t = Transcript.start("08-database-strategies.txt",
|
||||
threads + " connections released at once, all holding seat D4 of SH-1, repeated " + rounds + " times per strategy (H2 " + h2Version() + ")");
|
||||
t.line("optimistic (SELECT, then UPDATE ... WHERE version = ?): rounds with exactly one winner: " + optimistic + " of " + rounds);
|
||||
t.line("pessimistic (SELECT ... FOR UPDATE, then UPDATE): rounds with exactly one winner: " + pessimistic + " of " + rounds);
|
||||
t.line("conditional (one UPDATE ... WHERE state = 'AVAILABLE'): rounds with exactly one winner: " + conditional + " of " + rounds);
|
||||
|
||||
int naive = roundsWithExactlyOneWinner(store,
|
||||
(s, h, n, e) -> s.holdNaive("SH-1", "D4", h, n, e), threads, rounds);
|
||||
t.blank();
|
||||
t.line("Control, not asserted and timing dependent:");
|
||||
t.line("naive (SELECT, then UPDATE with no version or lock): rounds with exactly one winner: " + naive + " of " + rounds);
|
||||
t.flush();
|
||||
}
|
||||
|
||||
private static String h2Version() {
|
||||
return org.h2.engine.Constants.VERSION;
|
||||
}
|
||||
}
|
||||
+139
@@ -0,0 +1,139 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Fixtures;
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Transcript;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static com.ankurm.interviewlab.bookmyshow.support.Fixtures.SHOW_ID;
|
||||
import static com.ankurm.interviewlab.bookmyshow.support.Fixtures.describe;
|
||||
import static com.ankurm.interviewlab.bookmyshow.support.Fixtures.t;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
/** Section 8: a hold is a promise with a deadline, and payment is slow. Fake clock, no sleeping. */
|
||||
class ExpiryAndPaymentTest {
|
||||
private static final Duration TTL = Duration.ofMinutes(5);
|
||||
|
||||
private static String now(MutableClock c) {
|
||||
return t(c.instant());
|
||||
}
|
||||
|
||||
private static List<String> scenarios(String inventoryName) {
|
||||
List<String> log = new ArrayList<>();
|
||||
|
||||
// 1. paying just inside the deadline ---------------------------------------------------------------
|
||||
{
|
||||
MutableClock clock = Fixtures.clock();
|
||||
SeatInventory inv = Fixtures.fresh(inventoryName, clock);
|
||||
FakePaymentGateway pay = new FakePaymentGateway();
|
||||
BookingService svc = new BookingService(inv, clock, pay, TTL);
|
||||
Booking b = svc.startBooking("asha", SHOW_ID, List.of("B1"));
|
||||
clock.advance(Duration.ofMinutes(4).plusSeconds(59));
|
||||
BookingOutcome o = svc.pay(b.id());
|
||||
log.add("1. Pay one second before the deadline");
|
||||
log.add(" hold placed " + t(b.heldAt()) + ", expires " + t(b.expiresAt()) + ", pay pressed " + now(clock));
|
||||
log.add(" outcome: " + o + " charges: " + pay.charges() + " refunds: " + pay.refunds().size());
|
||||
assertEquals(BookingOutcome.CONFIRMED, o);
|
||||
}
|
||||
|
||||
// 2. the deadline passes, someone else takes the seat, the first user comes back ----------------------
|
||||
{
|
||||
MutableClock clock = Fixtures.clock();
|
||||
SeatInventory inv = Fixtures.fresh(inventoryName, clock);
|
||||
FakePaymentGateway pay = new FakePaymentGateway();
|
||||
BookingService svc = new BookingService(inv, clock, pay, TTL);
|
||||
Booking asha = svc.startBooking("asha", SHOW_ID, List.of("B1", "B2"));
|
||||
clock.advance(Duration.ofMinutes(4).plusSeconds(59));
|
||||
log.add("2. The deadline passes while Asha is on the payment page (she holds B1 and B2)");
|
||||
log.add(" " + now(clock) + " B1 reads as " + inv.stateOf(SHOW_ID, "B1"));
|
||||
clock.advance(Duration.ofSeconds(1));
|
||||
log.add(" " + now(clock) + " B1 reads as " + inv.stateOf(SHOW_ID, "B1")
|
||||
+ " (stored slot still says " + inv.slot(SHOW_ID, "B1").state() + ": expiry is lazy)");
|
||||
clock.advance(Duration.ofSeconds(1));
|
||||
Booking ravi = svc.startBooking("ravi", SHOW_ID, List.of("B1"));
|
||||
log.add(" " + now(clock) + " Ravi asks for B1: " + ravi.id() + " " + ravi.status());
|
||||
clock.advance(Duration.ofSeconds(1));
|
||||
BookingOutcome o = svc.pay(asha.id());
|
||||
log.add(" " + now(clock) + " Asha presses Pay: " + o + " charges: " + pay.charges());
|
||||
log.add(" B1: " + describe(inv.slot(SHOW_ID, "B1")));
|
||||
log.add(" B2: " + describe(inv.slot(SHOW_ID, "B2")));
|
||||
assertEquals(BookingOutcome.HOLD_EXPIRED_BEFORE_PAYMENT, o);
|
||||
assertEquals(0, pay.charges());
|
||||
assertEquals("BK-0002", inv.slot(SHOW_ID, "B1").holdId());
|
||||
}
|
||||
|
||||
// 3. payment is slow and the hold runs out while the bank is thinking --------------------------------
|
||||
{
|
||||
MutableClock clock = Fixtures.clock();
|
||||
SeatInventory inv = Fixtures.fresh(inventoryName, clock);
|
||||
FakePaymentGateway pay = new FakePaymentGateway();
|
||||
pay.duringCharge(() -> clock.advance(Duration.ofMinutes(2)));
|
||||
BookingService svc = new BookingService(inv, clock, pay, TTL);
|
||||
Booking asha = svc.startBooking("asha", SHOW_ID, List.of("B3"));
|
||||
clock.advance(Duration.ofMinutes(4).plusSeconds(59));
|
||||
log.add("3. Pay pressed at " + now(clock) + ", the gateway takes two minutes, nobody else wants the seat");
|
||||
BookingOutcome o = svc.pay(asha.id());
|
||||
log.add(" outcome: " + o + " charges: " + pay.charges() + " refunds: " + pay.refunds()
|
||||
+ " booking: " + svc.booking(asha.id()).status());
|
||||
assertEquals(BookingOutcome.HOLD_LOST_AFTER_PAYMENT, o);
|
||||
assertEquals(1, pay.charges());
|
||||
assertEquals(1, pay.refunds().size());
|
||||
}
|
||||
|
||||
// 4. same, but Ravi grabs the seat while the bank is thinking ---------------------------------------
|
||||
{
|
||||
MutableClock clock = Fixtures.clock();
|
||||
SeatInventory inv = Fixtures.fresh(inventoryName, clock);
|
||||
FakePaymentGateway pay = new FakePaymentGateway();
|
||||
BookingService svc = new BookingService(inv, clock, pay, TTL);
|
||||
Booking asha = svc.startBooking("asha", SHOW_ID, List.of("B4"));
|
||||
pay.duringCharge(() -> {
|
||||
clock.advance(Duration.ofMinutes(2));
|
||||
svc.startBooking("ravi", SHOW_ID, List.of("B4"));
|
||||
});
|
||||
clock.advance(Duration.ofMinutes(4).plusSeconds(59));
|
||||
log.add("4. Same slow payment, but Ravi takes B4 while the gateway is still working on Asha's charge");
|
||||
BookingOutcome o = svc.pay(asha.id());
|
||||
log.add(" outcome: " + o + " charges: " + pay.charges() + " refunds: " + pay.refunds()
|
||||
+ " booking: " + svc.booking(asha.id()).status());
|
||||
log.add(" B4: " + describe(inv.slot(SHOW_ID, "B4")));
|
||||
assertEquals(BookingOutcome.HOLD_LOST_AFTER_PAYMENT, o);
|
||||
assertEquals("BK-0002", inv.slot(SHOW_ID, "B4").holdId());
|
||||
}
|
||||
|
||||
// 5. card declined -------------------------------------------------------------------------------------
|
||||
{
|
||||
MutableClock clock = Fixtures.clock();
|
||||
SeatInventory inv = Fixtures.fresh(inventoryName, clock);
|
||||
FakePaymentGateway pay = new FakePaymentGateway();
|
||||
pay.declineNext();
|
||||
BookingService svc = new BookingService(inv, clock, pay, TTL);
|
||||
Booking asha = svc.startBooking("asha", SHOW_ID, List.of("B5"));
|
||||
BookingOutcome o = svc.pay(asha.id());
|
||||
log.add("5. The card is declined");
|
||||
log.add(" outcome: " + o + " booking: " + svc.booking(asha.id()).status() + " B5 now: " + inv.stateOf(SHOW_ID, "B5"));
|
||||
assertEquals(BookingOutcome.PAYMENT_DECLINED, o);
|
||||
assertEquals(SeatState.AVAILABLE, inv.stateOf(SHOW_ID, "B5"));
|
||||
}
|
||||
return log;
|
||||
}
|
||||
|
||||
@Test
|
||||
void holdExpiryAndPaymentTimeout() {
|
||||
List<List<String>> logs = new ArrayList<>();
|
||||
for (String name : Fixtures.NAMES) {
|
||||
logs.add(scenarios(name));
|
||||
}
|
||||
assertEquals(logs.get(0), logs.get(1));
|
||||
assertEquals(logs.get(0), logs.get(2));
|
||||
|
||||
Transcript tr = Transcript.start("06-expiry-and-payment.txt",
|
||||
"Hold expiry and payment timeout on a fake clock (TTL 5 minutes, no sleeping)");
|
||||
logs.get(0).forEach(tr::line);
|
||||
tr.blank().line("Same log produced by all three inventories: true");
|
||||
tr.flush();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Fixtures;
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Transcript;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static com.ankurm.interviewlab.bookmyshow.support.Fixtures.SHOW_ID;
|
||||
import static com.ankurm.interviewlab.bookmyshow.support.Fixtures.describe;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/** Section 3 of the article: with one user at a time, all three inventories behave identically. */
|
||||
class HappyPathTest {
|
||||
|
||||
private static List<String> run(SeatInventory inv, MutableClock clock) {
|
||||
FakePaymentGateway pay = new FakePaymentGateway();
|
||||
BookingService svc = new BookingService(inv, clock, pay, Duration.ofMinutes(5));
|
||||
List<String> log = new ArrayList<>();
|
||||
log.add("A1 at the start: " + describe(inv.slot(SHOW_ID, "A1")));
|
||||
|
||||
Booking b = svc.startBooking("asha", SHOW_ID, List.of("A1", "A2"));
|
||||
log.add("startBooking(asha, A1+A2): " + b.id() + " " + b.status() + ", Rs " + b.amountRupees());
|
||||
log.add("A1 after the hold: " + describe(inv.slot(SHOW_ID, "A1")));
|
||||
log.add("A3 untouched: " + describe(inv.slot(SHOW_ID, "A3")));
|
||||
|
||||
try {
|
||||
svc.startBooking("ravi", SHOW_ID, List.of("A2", "A3"));
|
||||
} catch (SeatUnavailableException e) {
|
||||
log.add("startBooking(ravi, A2+A3): refused (" + e.getMessage() + ")");
|
||||
}
|
||||
log.add("A3 after ravi's refusal: " + describe(inv.slot(SHOW_ID, "A3")));
|
||||
|
||||
BookingOutcome outcome = svc.pay(b.id());
|
||||
log.add("pay(" + b.id() + "): " + outcome + ", booking is " + svc.booking(b.id()).status());
|
||||
log.add("A1 after payment: " + describe(inv.slot(SHOW_ID, "A1")));
|
||||
log.add("seat summary: " + Fixtures.summaryAsStrings(inv, SHOW_ID));
|
||||
return log;
|
||||
}
|
||||
|
||||
@Test
|
||||
void singleThreadedFlowIsIdenticalAcrossImplementations() {
|
||||
List<List<String>> logs = new ArrayList<>();
|
||||
for (String name : Fixtures.NAMES) {
|
||||
MutableClock clock = Fixtures.clock();
|
||||
logs.add(run(Fixtures.fresh(name, clock), clock));
|
||||
}
|
||||
assertEquals(logs.get(0), logs.get(1));
|
||||
assertEquals(logs.get(0), logs.get(2));
|
||||
|
||||
List<String> log = logs.get(0);
|
||||
assertTrue(log.get(8).endsWith("{AVAILABLE=58, BOOKED=2, HELD=0}"), log.get(8));
|
||||
|
||||
Transcript t = Transcript.start("01-happy-path.txt",
|
||||
"Happy path, one user at a time (show SH-1, 60 seats, hold TTL 5 minutes)");
|
||||
log.forEach(t::line);
|
||||
t.blank().line("Same log produced by NaiveInventory, PessimisticInventory and OptimisticInventory: true");
|
||||
t.flush();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Fixtures;
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Transcript;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.CyclicBarrier;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import static com.ankurm.interviewlab.bookmyshow.RaceConditionTest.runTogether;
|
||||
import static com.ankurm.interviewlab.bookmyshow.support.Fixtures.SHOW_ID;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* Sections 5 and 6: the order in which a request touches several seats decides whether pessimistic locking deadlocks
|
||||
* and whether optimistic holding refuses two requests that could have been served one after the other.
|
||||
*/
|
||||
class LockOrderingTest {
|
||||
private static final Duration TTL = Duration.ofMinutes(5);
|
||||
|
||||
private static Runnable barrier(CyclicBarrier b) {
|
||||
return () -> {
|
||||
try {
|
||||
b.await(10, TimeUnit.SECONDS);
|
||||
} catch (Exception e) {
|
||||
throw new IllegalStateException(e);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
private static List<Callable<Boolean>> twoCrossedRequests(SeatInventory inv) {
|
||||
return List.of(
|
||||
() -> inv.tryHold(SHOW_ID, List.of("A1", "A2"), "H1", TTL),
|
||||
() -> inv.tryHold(SHOW_ID, List.of("A2", "A1"), "H2", TTL));
|
||||
}
|
||||
|
||||
@Test
|
||||
void orderMattersForBothFamilies() throws Exception {
|
||||
Transcript t = Transcript.start("03-lock-ordering.txt",
|
||||
"Two requests for the same two seats, listed in opposite order: H1 asks [A1, A2], H2 asks [A2, A1]");
|
||||
|
||||
// --- pessimistic, locks taken in the order requested ---------------------------------------------------
|
||||
MutableClock c1 = Fixtures.clock();
|
||||
PessimisticInventory unsorted = new PessimisticInventory(c1, AcquireOrder.AS_REQUESTED, Duration.ofMillis(300));
|
||||
unsorted.register(Fixtures.show());
|
||||
unsorted.afterFirstLock(barrier(new CyclicBarrier(2)));
|
||||
long started = System.nanoTime();
|
||||
List<Boolean> r1 = runTogether(twoCrossedRequests(unsorted));
|
||||
long stalledMillis = (System.nanoTime() - started) / 1_000_000;
|
||||
long succeeded = r1.stream().filter(b -> b).count();
|
||||
assertTrue(stalledMillis >= 290, "both threads were stuck until a lock wait timed out, took " + stalledMillis + " ms");
|
||||
assertTrue(unsorted.lockTimeouts() >= 1);
|
||||
assertTrue(succeeded <= 1);
|
||||
t.line("PessimisticInventory, AS_REQUESTED (each thread holds one lock, then waits for the other's):");
|
||||
t.line(" stuck until a lock wait timed out (300 ms): true");
|
||||
t.line(" at least one lock wait timed out: " + (unsorted.lockTimeouts() >= 1));
|
||||
t.line(" requests that succeeded: at most 1 (never both; which one is timing dependent)");
|
||||
t.line(" Without the timeout both threads would wait forever.");
|
||||
|
||||
// --- pessimistic, sorted -------------------------------------------------------------------------------
|
||||
PessimisticInventory sorted = new PessimisticInventory(Fixtures.clock(), AcquireOrder.SORTED, Duration.ofMillis(300));
|
||||
sorted.register(Fixtures.show());
|
||||
List<Boolean> r2 = runTogether(twoCrossedRequests(sorted));
|
||||
assertEquals(1, r2.stream().filter(b -> b).count());
|
||||
assertEquals(0, sorted.lockTimeouts());
|
||||
t.blank();
|
||||
t.line("PessimisticInventory, SORTED (both requests lock A1 first, so one simply waits):");
|
||||
t.line(" requests that succeeded: " + r2.stream().filter(b -> b).count() + " of 2");
|
||||
t.line(" lock waits that timed out: " + sorted.lockTimeouts());
|
||||
|
||||
// --- optimistic, taken in the order requested ----------------------------------------------------------
|
||||
OptimisticInventory optUnsorted = new OptimisticInventory(Fixtures.clock(), AcquireOrder.AS_REQUESTED);
|
||||
optUnsorted.register(Fixtures.show());
|
||||
optUnsorted.afterFirstAcquire(barrier(new CyclicBarrier(2)));
|
||||
optUnsorted.beforeRollback(barrier(new CyclicBarrier(2))); // second barrier: both see the other's seat before either hands its own back
|
||||
List<Boolean> r3 = runTogether(twoCrossedRequests(optUnsorted));
|
||||
assertEquals(List.of(false, false), r3);
|
||||
assertEquals(SeatState.AVAILABLE, optUnsorted.stateOf(SHOW_ID, "A1"));
|
||||
assertEquals(SeatState.AVAILABLE, optUnsorted.stateOf(SHOW_ID, "A2"));
|
||||
long v1 = optUnsorted.slot(SHOW_ID, "A1").version();
|
||||
long v2 = optUnsorted.slot(SHOW_ID, "A2").version();
|
||||
assertEquals(2, v1);
|
||||
assertEquals(2, v2);
|
||||
t.blank();
|
||||
t.line("OptimisticInventory, AS_REQUESTED (each request takes one seat, then finds the other taken):");
|
||||
t.line(" results: " + r3);
|
||||
t.line(" A1 / A2 afterwards: " + optUnsorted.stateOf(SHOW_ID, "A1") + " / " + optUnsorted.stateOf(SHOW_ID, "A2")
|
||||
+ " (versions v" + v1 + " / v" + v2 + ": held, then handed back)");
|
||||
t.line(" Both seats are free and both customers were turned away.");
|
||||
|
||||
// --- optimistic, sorted --------------------------------------------------------------------------------
|
||||
OptimisticInventory optSorted = new OptimisticInventory(Fixtures.clock(), AcquireOrder.SORTED);
|
||||
optSorted.register(Fixtures.show());
|
||||
List<Boolean> r4 = runTogether(twoCrossedRequests(optSorted));
|
||||
assertEquals(1, r4.stream().filter(b -> b).count());
|
||||
t.blank();
|
||||
t.line("OptimisticInventory, SORTED (both start at A1, so only one can get past the first seat):");
|
||||
t.line(" requests that succeeded: " + r4.stream().filter(b -> b).count() + " of 2");
|
||||
assertTrue(optSorted.summary(SHOW_ID).get(SeatState.HELD) == 2);
|
||||
t.line(" HELD seats afterwards: " + optSorted.summary(SHOW_ID).get(SeatState.HELD));
|
||||
t.flush();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Fixtures;
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Transcript;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
import static com.ankurm.interviewlab.bookmyshow.RaceConditionTest.runTogether;
|
||||
import static com.ankurm.interviewlab.bookmyshow.support.Fixtures.SHOW_ID;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/** Section 9: the quiet mistakes. Each test pins one behaviour of the correct implementations. */
|
||||
class PitfallsTest {
|
||||
private static final Duration TTL = Duration.ofMinutes(5);
|
||||
|
||||
@Test
|
||||
void pitfalls() throws Exception {
|
||||
Transcript t = Transcript.start("07-pitfalls.txt", "Pitfalls: partial holds, foreign releases, bad input, double Pay");
|
||||
|
||||
// 1. a multi-seat request that fails half way must leave nothing behind ---------------------------------
|
||||
t.line("1. Request [A1, A2, A3] while someone else holds A3");
|
||||
for (String name : Fixtures.NAMES) {
|
||||
MutableClock clock = Fixtures.clock();
|
||||
SeatInventory inv = Fixtures.fresh(name, clock);
|
||||
assertTrue(inv.tryHold(SHOW_ID, List.of("A3"), "OTHER", TTL));
|
||||
boolean ok = inv.tryHold(SHOW_ID, List.of("A1", "A2", "A3"), "ME", TTL);
|
||||
assertFalse(ok);
|
||||
assertEquals(SeatState.AVAILABLE, inv.stateOf(SHOW_ID, "A1"));
|
||||
assertEquals(SeatState.AVAILABLE, inv.stateOf(SHOW_ID, "A2"));
|
||||
t.line(" %-21s result %-5s A1 %-9s v%d A2 %-9s v%d".formatted(name, ok,
|
||||
inv.stateOf(SHOW_ID, "A1"), inv.slot(SHOW_ID, "A1").version(),
|
||||
inv.stateOf(SHOW_ID, "A2"), inv.slot(SHOW_ID, "A2").version()));
|
||||
}
|
||||
t.line(" (v0 means the seat was never touched; v2 means it was held and handed back during the attempt)");
|
||||
|
||||
// 2. release and confirm only work on your own hold ----------------------------------------------------
|
||||
t.blank();
|
||||
t.line("2. Someone who does not own the hold tries to release or confirm it");
|
||||
for (String name : Fixtures.NAMES) {
|
||||
SeatInventory inv = Fixtures.fresh(name, Fixtures.clock());
|
||||
assertTrue(inv.tryHold(SHOW_ID, List.of("C1"), "ASHA", TTL));
|
||||
inv.release(SHOW_ID, List.of("C1"), "RAVI");
|
||||
boolean foreignConfirm = inv.confirm(SHOW_ID, List.of("C1"), "RAVI");
|
||||
assertFalse(foreignConfirm);
|
||||
assertEquals("ASHA", inv.slot(SHOW_ID, "C1").holdId());
|
||||
assertEquals(SeatState.HELD, inv.stateOf(SHOW_ID, "C1"));
|
||||
t.line(" %-21s after Ravi's release and confirm: C1 is %s by %s, Ravi's confirm returned %s".formatted(
|
||||
name, inv.stateOf(SHOW_ID, "C1"), inv.slot(SHOW_ID, "C1").holdId(), foreignConfirm));
|
||||
}
|
||||
|
||||
// 3. a booked seat cannot be released by anyone, including its owner ------------------------------------
|
||||
t.blank();
|
||||
t.line("3. A BOOKED seat is not released by release(), even by its owner");
|
||||
for (String name : Fixtures.NAMES) {
|
||||
SeatInventory inv = Fixtures.fresh(name, Fixtures.clock());
|
||||
assertTrue(inv.tryHold(SHOW_ID, List.of("C2"), "ASHA", TTL));
|
||||
assertTrue(inv.confirm(SHOW_ID, List.of("C2"), "ASHA"));
|
||||
inv.release(SHOW_ID, List.of("C2"), "ASHA");
|
||||
assertEquals(SeatState.BOOKED, inv.stateOf(SHOW_ID, "C2"));
|
||||
assertFalse(inv.tryHold(SHOW_ID, List.of("C2"), "RAVI", TTL));
|
||||
t.line(" %-21s C2 after owner's release: %s, a new hold on it returns false".formatted(name, inv.stateOf(SHOW_ID, "C2")));
|
||||
}
|
||||
|
||||
// 4. bad input is refused before any state changes -----------------------------------------------------
|
||||
t.blank();
|
||||
t.line("4. Bad input (identical for all three inventories)");
|
||||
SeatInventory inv4 = Fixtures.fresh("OptimisticInventory", Fixtures.clock());
|
||||
String dup = assertThrows(IllegalArgumentException.class,
|
||||
() -> inv4.tryHold(SHOW_ID, List.of("A1", "A1"), "X", TTL)).getMessage();
|
||||
String unknown = assertThrows(IllegalArgumentException.class,
|
||||
() -> inv4.tryHold(SHOW_ID, List.of("Z99"), "X", TTL)).getMessage();
|
||||
String empty = assertThrows(IllegalArgumentException.class,
|
||||
() -> inv4.tryHold(SHOW_ID, List.of(), "X", TTL)).getMessage();
|
||||
String noShow = assertThrows(IllegalArgumentException.class,
|
||||
() -> inv4.tryHold("SH-404", List.of("A1"), "X", TTL)).getMessage();
|
||||
for (String name : Fixtures.NAMES) {
|
||||
SeatInventory inv = Fixtures.fresh(name, Fixtures.clock());
|
||||
assertEquals(dup, assertThrows(IllegalArgumentException.class, () -> inv.tryHold(SHOW_ID, List.of("A1", "A1"), "X", TTL)).getMessage());
|
||||
assertEquals(SeatState.AVAILABLE, inv.stateOf(SHOW_ID, "A1"));
|
||||
}
|
||||
t.line(" duplicate seat ids: IllegalArgumentException: " + dup);
|
||||
t.line(" unknown seat: IllegalArgumentException: " + unknown);
|
||||
t.line(" no seats at all: IllegalArgumentException: " + empty);
|
||||
t.line(" unknown show: IllegalArgumentException: " + noShow);
|
||||
|
||||
// 5. pressing Pay twice ----------------------------------------------------------------------------------
|
||||
t.blank();
|
||||
t.line("5. Pay pressed 50 times at once for the same booking");
|
||||
MutableClock clock = Fixtures.clock();
|
||||
SeatInventory inv = Fixtures.fresh("OptimisticInventory", clock);
|
||||
FakePaymentGateway pay = new FakePaymentGateway();
|
||||
BookingService svc = new BookingService(inv, clock, pay, TTL);
|
||||
Booking b = svc.startBooking("asha", SHOW_ID, List.of("D1"));
|
||||
AtomicInteger confirmed = new AtomicInteger();
|
||||
AtomicInteger refused = new AtomicInteger();
|
||||
List<java.util.concurrent.Callable<Void>> clicks = new java.util.ArrayList<>();
|
||||
for (int i = 0; i < 50; i++) {
|
||||
clicks.add(() -> {
|
||||
try {
|
||||
if (svc.pay(b.id()) == BookingOutcome.CONFIRMED) {
|
||||
confirmed.incrementAndGet();
|
||||
}
|
||||
} catch (IllegalStateException e) {
|
||||
refused.incrementAndGet();
|
||||
}
|
||||
return null;
|
||||
});
|
||||
}
|
||||
runTogether(clicks);
|
||||
assertEquals(1, confirmed.get());
|
||||
assertEquals(49, refused.get());
|
||||
assertEquals(1, pay.charges());
|
||||
t.line(" calls that confirmed: " + confirmed.get());
|
||||
t.line(" calls refused with IllegalStateException: " + refused.get());
|
||||
t.line(" times the card was charged: " + pay.charges());
|
||||
t.flush();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
package com.ankurm.interviewlab.bookmyshow;
|
||||
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Fixtures;
|
||||
import com.ankurm.interviewlab.bookmyshow.support.Transcript;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
import java.util.concurrent.CyclicBarrier;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.Future;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import static com.ankurm.interviewlab.bookmyshow.support.Fixtures.SHOW_ID;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
/** Section 4 and the first half of 5/6: two people, one seat. */
|
||||
class RaceConditionTest {
|
||||
|
||||
/** Runs the tasks on separate threads released at the same instant. */
|
||||
static <T> List<T> runTogether(List<Callable<T>> tasks) throws Exception {
|
||||
ExecutorService pool = Executors.newFixedThreadPool(tasks.size());
|
||||
CountDownLatch go = new CountDownLatch(1);
|
||||
List<Future<T>> futures = new ArrayList<>();
|
||||
for (Callable<T> task : tasks) {
|
||||
futures.add(pool.submit(() -> {
|
||||
go.await();
|
||||
return task.call();
|
||||
}));
|
||||
}
|
||||
go.countDown();
|
||||
List<T> results = new ArrayList<>();
|
||||
for (Future<T> f : futures) {
|
||||
results.add(f.get(30, TimeUnit.SECONDS));
|
||||
}
|
||||
pool.shutdown();
|
||||
return results;
|
||||
}
|
||||
|
||||
private static Callable<String> tryBooking(BookingService svc, String user, String seat) {
|
||||
return () -> {
|
||||
try {
|
||||
return svc.startBooking(user, SHOW_ID, List.of(seat)).id();
|
||||
} catch (SeatUnavailableException e) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@Test
|
||||
void naiveCheckThenActGrantsTheSameSeatTwice() throws Exception {
|
||||
MutableClock clock = Fixtures.clock();
|
||||
NaiveInventory inv = new NaiveInventory(clock);
|
||||
inv.register(Fixtures.show());
|
||||
CyclicBarrier bothHaveChecked = new CyclicBarrier(2);
|
||||
inv.betweenCheckAndAct(() -> {
|
||||
try {
|
||||
bothHaveChecked.await(10, TimeUnit.SECONDS);
|
||||
} catch (Exception e) {
|
||||
throw new IllegalStateException(e);
|
||||
}
|
||||
});
|
||||
FakePaymentGateway pay = new FakePaymentGateway();
|
||||
BookingService svc = new BookingService(inv, clock, pay, Duration.ofMinutes(5));
|
||||
|
||||
List<String> ids = runTogether(List.of(tryBooking(svc, "asha", "C5"), tryBooking(svc, "ravi", "C5")));
|
||||
long holdsGranted = ids.stream().filter(java.util.Objects::nonNull).count();
|
||||
assertEquals(2, holdsGranted, "the race is made to happen on every run by the barrier");
|
||||
|
||||
inv.betweenCheckAndAct(() -> { });
|
||||
List<BookingOutcome> outcomes = new ArrayList<>();
|
||||
for (String id : ids) {
|
||||
outcomes.add(svc.pay(id));
|
||||
}
|
||||
Collections.sort(outcomes);
|
||||
assertEquals(List.of(BookingOutcome.CONFIRMED, BookingOutcome.HOLD_LOST_AFTER_PAYMENT), outcomes);
|
||||
assertEquals(2, pay.charges());
|
||||
assertEquals(1, pay.refunds().size());
|
||||
|
||||
Transcript t = Transcript.start("02-naive-race.txt",
|
||||
"NaiveInventory: two users request seat C5 at the same moment (barrier forces both reads before either write)");
|
||||
t.line("holds granted for C5: " + holdsGranted + " (a seat can only be sold once)");
|
||||
t.line("both users now pay:");
|
||||
t.line(" outcomes (sorted): " + outcomes);
|
||||
t.line(" customers charged: " + pay.charges());
|
||||
t.line(" customers refunded: " + pay.refunds().size());
|
||||
t.line("C5 in the end: " + Fixtures.describe(inv.slot(SHOW_ID, "C5")).replaceAll("BK-000[12]", "BK-000x"));
|
||||
t.blank();
|
||||
t.line("Neither thread did anything unusual. Each ran check, then act, and the barrier only decided");
|
||||
t.line("that both checks finished before either act began.");
|
||||
|
||||
for (String name : List.of("PessimisticInventory", "OptimisticInventory")) {
|
||||
MutableClock c2 = Fixtures.clock();
|
||||
SeatInventory safe = Fixtures.fresh(name, c2);
|
||||
BookingService svc2 = new BookingService(safe, c2, new FakePaymentGateway(), Duration.ofMinutes(5));
|
||||
List<String> r = runTogether(List.of(tryBooking(svc2, "asha", "C5"), tryBooking(svc2, "ravi", "C5")));
|
||||
long granted = r.stream().filter(java.util.Objects::nonNull).count();
|
||||
assertEquals(1, granted);
|
||||
t.blank();
|
||||
t.line(name + ", same two users at the same moment:");
|
||||
t.line(" holds granted for C5: " + granted);
|
||||
t.line(" loser sees: SeatUnavailableException");
|
||||
}
|
||||
t.flush();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package com.ankurm.interviewlab.bookmyshow.support;
|
||||
|
||||
import com.ankurm.interviewlab.bookmyshow.MutableClock;
|
||||
import com.ankurm.interviewlab.bookmyshow.NaiveInventory;
|
||||
import com.ankurm.interviewlab.bookmyshow.OptimisticInventory;
|
||||
import com.ankurm.interviewlab.bookmyshow.PessimisticInventory;
|
||||
import com.ankurm.interviewlab.bookmyshow.SeatInventory;
|
||||
import com.ankurm.interviewlab.bookmyshow.SeatSlot;
|
||||
import com.ankurm.interviewlab.bookmyshow.Show;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.TreeMap;
|
||||
|
||||
/** Shared setup so every test starts from the same show, the same clock and the same three inventories. */
|
||||
public final class Fixtures {
|
||||
public static final Instant T0 = Instant.parse("2026-11-20T10:00:00Z");
|
||||
public static final String SHOW_ID = "SH-1";
|
||||
|
||||
private Fixtures() { }
|
||||
|
||||
public static MutableClock clock() {
|
||||
return new MutableClock(T0);
|
||||
}
|
||||
|
||||
/** 6 rows x 10 seats: A..D regular (Rs 220), E premium (Rs 350), F recliner (Rs 600). */
|
||||
public static Show show() {
|
||||
return Show.grid(SHOW_ID, "The Last Local", "Screen 3", Instant.parse("2026-11-21T14:00:00Z"), 6, 10);
|
||||
}
|
||||
|
||||
/** The three implementations by name. Each call to {@link #fresh} builds a new inventory with the show registered. */
|
||||
public static final List<String> NAMES = List.of("NaiveInventory", "PessimisticInventory", "OptimisticInventory");
|
||||
|
||||
public static SeatInventory fresh(String name, MutableClock clock) {
|
||||
SeatInventory inv = switch (name) {
|
||||
case "NaiveInventory" -> new NaiveInventory(clock);
|
||||
case "PessimisticInventory" -> new PessimisticInventory(clock);
|
||||
case "OptimisticInventory" -> new OptimisticInventory(clock);
|
||||
default -> throw new IllegalArgumentException(name);
|
||||
};
|
||||
inv.register(show());
|
||||
return inv;
|
||||
}
|
||||
|
||||
/** "T+04:59" style label, relative to the clock's start, so transcripts do not depend on the date the tests ran. */
|
||||
public static String t(Instant when) {
|
||||
long s = Duration.between(T0, when).getSeconds();
|
||||
return "T+%02d:%02d".formatted(s / 60, s % 60);
|
||||
}
|
||||
|
||||
public static String describe(SeatSlot slot) {
|
||||
return switch (slot.state()) {
|
||||
case AVAILABLE -> "AVAILABLE v" + slot.version();
|
||||
case HELD -> "HELD by %s until %s v%d".formatted(slot.holdId(), t(slot.expiresAt()), slot.version());
|
||||
case BOOKED -> "BOOKED by %s v%d".formatted(slot.holdId(), slot.version());
|
||||
};
|
||||
}
|
||||
|
||||
public static Map<String, Long> summaryAsStrings(SeatInventory inv, String showId) {
|
||||
Map<String, Long> m = new TreeMap<>();
|
||||
inv.summary(showId).forEach((k, v) -> m.put(k.name(), v));
|
||||
return m;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
package com.ankurm.interviewlab.bookmyshow.support;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.UncheckedIOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/** Writes output/NN-*.txt while the calling test asserts the same numbers it prints. */
|
||||
public final class Transcript {
|
||||
private final Path path;
|
||||
private final List<String> lines = new ArrayList<>();
|
||||
|
||||
private Transcript(Path path, String header) {
|
||||
this.path = path;
|
||||
lines.add(header);
|
||||
lines.add("=".repeat(Math.min(header.length(), 100)));
|
||||
lines.add("");
|
||||
}
|
||||
|
||||
public static Transcript start(String fileName, String header) {
|
||||
Path dir = Path.of("output");
|
||||
try {
|
||||
Files.createDirectories(dir);
|
||||
} catch (IOException e) {
|
||||
throw new UncheckedIOException(e);
|
||||
}
|
||||
return new Transcript(dir.resolve(fileName), header);
|
||||
}
|
||||
|
||||
public Transcript line(String text) { lines.add(text); return this; }
|
||||
public Transcript blank() { lines.add(""); return this; }
|
||||
|
||||
public void flush() {
|
||||
try {
|
||||
Files.write(path, (String.join("\n", lines) + "\n").getBytes(StandardCharsets.UTF_8));
|
||||
} catch (IOException e) {
|
||||
throw new UncheckedIOException(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user