package com.example.lockdeepdive.inventory;
// Pattern: Gegenbeispiel - diese Klasse zeigt bewusst den Lost-Update-Fehler.
public final class NaiveReservationSession {
    private final InventoryTable table;
    private final StockSnapshot snapshot;
    private Integer plannedQuantity;
    public NaiveReservationSession(InventoryTable table, StockSnapshot snapshot) {
        this.table = table;
        this.snapshot = snapshot;
    }
public boolean planReservation(int requested) {
    if (requested <= 0) throw new IllegalArgumentException("requested must be positive");
    if (snapshot.quantity() < requested) return false;
    plannedQuantity = snapshot.quantity() - requested;
    return true;
}
public void commitWithoutVersionCheck() {
    if (plannedQuantity == null) throw new IllegalStateException("nothing planned");
    table.writeWithoutVersionCheck(snapshot.productId(), plannedQuantity);
}
public StockSnapshot snapshot() {
    return snapshot;
}
}

UPDATE inventory
 SET quantity = ?, version = version + 1
 WHERE product_id = ?
 AND version = ?;
0 rows updated -> jemand war schneller; Konflikt behandeln
1 row updated -> Commit kann fortgesetzt werden

package com.example.lockdeepdive.inventory;
import com.example.lockdeepdive.shared.*;
// Pattern: Application Service - kapselt Use-Case-Regeln und technische Konfliktbehandlung.
public final class OptimisticInventoryService {
    private final InventoryTable table;
    private final int maxRetries;
    public OptimisticInventoryService(InventoryTable table, int maxRetries) {
        this.table = table;
        this.maxRetries = maxRetries;
    }
public ReservationResult reserve(ProductId productId, int requested) {
    for (int attempt = 1; attempt <= maxRetries; attempt++) {
        StockSnapshot current = table.read(productId);
        if (current.quantity() < requested) {
            return new ReservationResult.Rejected(productId, requested, current.quantity());
        }
    int newQuantity = current.quantity() - requested;
    try {
        StockSnapshot saved = table.writeIfVersionMatches(productId, current.version(), newQuantity);
        return new ReservationResult.Reserved(productId, requested, saved.quantity(), saved.version());
    }
catch (OptimisticLockException conflict) {
    if (attempt == maxRetries) {
        return new ReservationResult.Conflict(productId, conflict.getMessage());
    }
// In echter Produktion: kleiner Backoff + Metrik + erneute fachliche Pruefung.
}
}
return new ReservationResult.Conflict(productId, "retry loop exhausted");
}
}

package com.example.lockdeepdive.isolation;
import java.util.*;
// Pattern: Unit of Work Mental Model - Transaktion merkt sich je nach Isolation gelesene Snapshots.
public final class SimulatedTransaction {
    private final AccountTable table;
    private final IsolationLevel isolationLevel;
    private final Map<AccountId, AccountSnapshot> repeatableReadCache = new HashMap<>();
    public SimulatedTransaction(AccountTable table, IsolationLevel isolationLevel) {
        this.table = table;
        this.isolationLevel = isolationLevel;
    }
public AccountSnapshot read(AccountId id) {
    if (isolationLevel == IsolationLevel.REPEATABLE_READ) {
        return repeatableReadCache.computeIfAbsent(id, table::committedRead);
    }
return table.committedRead(id);
}
public IsolationLevel isolationLevel() {
    return isolationLevel;
}
}

BEGIN;
SELECT quantity, version
 FROM inventory
 WHERE product_id = 'SKU-1'
 FOR UPDATE;
-- jetzt: pruefen, reduzieren, Outbox schreiben
COMMIT;

package com.example.lockdeepdive.locking;
import com.example.lockdeepdive.shared.ProductId;
import java.time.Duration;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
// Pattern: Lock Manager - simuliert DB-Zeilensperren mit Timeout.
public final class RowLockManager {
    private final ConcurrentMap<ProductId, ReentrantLock> locks = new ConcurrentHashMap<>();
    public Guard lock(ProductId productId, Duration timeout) {
        ReentrantLock lock = locks.computeIfAbsent(productId, id -> new ReentrantLock());
        try {
            if (!lock.tryLock(timeout.toMillis(), TimeUnit.MILLISECONDS)) {
                throw new LockTimeoutException("timeout while waiting for lock on " + productId);
            }
        return new Guard(productId, lock);
    }
catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    throw new LockTimeoutException("interrupted while waiting for lock on " + productId);
}
}
public record Guard(ProductId productId, ReentrantLock lock) implements AutoCloseable {
    @Override public void close() {
        lock.unlock();
    }
}
}

package com.example.lockdeepdive.locking;
import com.example.lockdeepdive.inventory.*;
import com.example.lockdeepdive.shared.*;
import java.time.Duration;
// Pattern: Application Service + Pessimistic Lock - kurze kritische Sektion, keine externen API-Aufrufe im Lock.
public final class PessimisticInventoryService {
    private final InventoryTable table;
    private final RowLockManager locks;
    private final Duration timeout;
    public PessimisticInventoryService(InventoryTable table, RowLockManager locks, Duration timeout) {
        this.table = table;
        this.locks = locks;
        this.timeout = timeout;
    }
public ReservationResult reserve(ProductId productId, int requested) {
    try (RowLockManager.Guard ignored = locks.lock(productId, timeout)) {
        StockSnapshot current = table.read(productId);
        if (current.quantity() < requested) {
            return new ReservationResult.Rejected(productId, requested, current.quantity());
        }
    StockSnapshot saved = table.writeIfVersionMatches(productId, current.version(), current.quantity() - requested);
    return new ReservationResult.Reserved(productId, requested, saved.quantity(), saved.version());
}
catch (LockTimeoutException timeout) {
    return new ReservationResult.Conflict(productId, timeout.getMessage());
}
}
}

package com.example.lockdeepdive.deadlock;
import java.time.Duration;
import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;
// Pattern: Deterministic Concurrency Test Helper - erzwingt gegensaetzliche Lock-Reihenfolge reproduzierbar.
public final class DeadlockSimulator {
    private final ReentrantLock productOne = new ReentrantLock();
    private final ReentrantLock productTwo = new ReentrantLock();
    public DeadlockSimulationResult simulateOppositeLockOrder(Duration timeout) {
        CountDownLatch bothHoldFirstLock = new CountDownLatch(2);
        ExecutorService executor = Executors.newFixedThreadPool(2);
        try {
            Future<Boolean> first = executor.submit(() -> worker(productOne, productTwo, bothHoldFirstLock, timeout));
            Future<Boolean> second = executor.submit(() -> worker(productTwo, productOne, bothHoldFirstLock, timeout));
            boolean firstTimedOut = first.get(5, TimeUnit.SECONDS);
            boolean secondTimedOut = second.get(5, TimeUnit.SECONDS);
            return new DeadlockSimulationResult(firstTimedOut, secondTimedOut,
            "opposite lock order created a wait cycle; timeout broke at least one worker");
        }
    catch (Exception e) {
        throw new IllegalStateException("deadlock simulation failed", e);
    }
finally {
    executor.shutdownNow();
}
}
private boolean worker(ReentrantLock first, ReentrantLock second, CountDownLatch latch, Duration timeout) throws Exception {
    first.lock();
    try {
        latch.countDown();
        if (!latch.await(2, TimeUnit.SECONDS)) throw new IllegalStateException("test setup failed");
        boolean acquiredSecond = second.tryLock(timeout.toMillis(), TimeUnit.MILLISECONDS);
        if (!acquiredSecond) return true;
        try {
            return false;
        }
    finally {
        second.unlock();
    }
}
finally {
    first.unlock();
}
}
}

@Entity
class InventoryItemEntity {
    @Id String productId;
    int quantity;
    @Version
    long version;
}
-- Hibernate-Update enthaelt typischerweise eine Versionsbedingung.

package com.example.lockdeepdive;
import com.example.lockdeepdive.deadlock.*;
import com.example.lockdeepdive.inventory.*;
import com.example.lockdeepdive.isolation.*;
import com.example.lockdeepdive.locking.*;
import com.example.lockdeepdive.shared.*;
import java.time.Duration;
public final class Kapitel2TestRunner {
    public static void main(String[] args) {
        lostUpdateIsVisibleWithoutVersionCheck();
        optimisticLockDetectsStaleWrite();
        optimisticServiceRechecksBusinessRuleAfterConflict();
        pessimisticLockSerializesCriticalSection();
        readCommittedAllowsNonRepeatableRead();
        repeatableReadKeepsStableSnapshot();
        deadlockIsBrokenByTimeout();
        System.out.println("Kapitel2_TESTS_OK");
    }
static void lostUpdateIsVisibleWithoutVersionCheck() {
    ProductId sku = ProductId.of("SKU-1");
    InventoryTable table = new InventoryTable();
    table.insert(sku, 10);
    NaiveReservationSession txA = new NaiveReservationSession(table, table.read(sku));
    NaiveReservationSession txB = new NaiveReservationSession(table, table.read(sku));
    assertTrue(txA.planReservation(7), "txA can reserve 7");
    assertTrue(txB.planReservation(6), "txB can reserve 6 based on stale snapshot");
    txA.commitWithoutVersionCheck();
    txB.commitWithoutVersionCheck();
    assertEquals(4, table.quantity(sku), "last writer wins although 13 items were promised from stock 10");
}
static void optimisticLockDetectsStaleWrite() {
    ProductId sku = ProductId.of("SKU-2");
    InventoryTable table = new InventoryTable();
    table.insert(sku, 10);
    StockSnapshot a = table.read(sku);
    StockSnapshot b = table.read(sku);
    table.writeIfVersionMatches(sku, a.version(), 3);
    assertThrows(OptimisticLockException.class, () -> table.writeIfVersionMatches(sku, b.version(), 4),
    "stale writer must be rejected");
}
static void optimisticServiceRechecksBusinessRuleAfterConflict() {
    ProductId sku = ProductId.of("SKU-3");
    InventoryTable table = new InventoryTable();
    table.insert(sku, 10);
    OptimisticInventoryService service = new OptimisticInventoryService(table, 3);
    ReservationResult first = service.reserve(sku, 7);
    ReservationResult second = service.reserve(sku, 6);
    assertTrue(first.success(), "first reservation succeeds");
    assertTrue(!second.success(), "second reservation is rejected after reread because only 3 remain");
}
static void pessimisticLockSerializesCriticalSection() {
    ProductId sku = ProductId.of("SKU-4");
    InventoryTable table = new InventoryTable();
    table.insert(sku, 10);
    PessimisticInventoryService service = new PessimisticInventoryService(table, new RowLockManager(), Duration.ofMillis(500));
    ReservationResult first = service.reserve(sku, 6);
    ReservationResult second = service.reserve(sku, 5);
    assertTrue(first.success(), "first reservation succeeds");
    assertTrue(!second.success(), "second reservation sees updated remaining stock and fails fachlich");
    assertEquals(4, table.quantity(sku), "stock remains consistent");
}
static void readCommittedAllowsNonRepeatableRead() {
    AccountId account = AccountId.of("A-1");
    AccountTable table = new AccountTable();
    table.insert(account, 100);
    SimulatedTransaction tx = new SimulatedTransaction(table, IsolationLevel.READ_COMMITTED);
    int first = tx.read(account).balance();
    table.update(account, 150);
    int second = tx.read(account).balance();
    assertEquals(100, first, "first read");
    assertEquals(150, second, "second read sees newer committed value");
}
static void repeatableReadKeepsStableSnapshot() {
    AccountId account = AccountId.of("A-2");
    AccountTable table = new AccountTable();
    table.insert(account, 100);
    SimulatedTransaction tx = new SimulatedTransaction(table, IsolationLevel.REPEATABLE_READ);
    int first = tx.read(account).balance();
    table.update(account, 150);
    int second = tx.read(account).balance();
    assertEquals(100, first, "first read");
    assertEquals(100, second, "repeatable read keeps snapshot stable inside transaction");
}
static void deadlockIsBrokenByTimeout() {
    DeadlockSimulationResult result = new DeadlockSimulator().simulateOppositeLockOrder(Duration.ofMillis(200));
    assertTrue(result.deadlockWasBrokenByTimeout(), "timeout should break wait cycle");
}
static void assertTrue(boolean condition, String message) {
    if (!condition) throw new AssertionError(message);
}
static void assertEquals(int expected, int actual, String message) {
    if (expected != actual) throw new AssertionError(message + ": expected=" + expected + ", actual=" + actual);
}
static void assertThrows(Class<? extends Throwable> type, Runnable action, String message) {
    try {
        action.Kapitel();
    }
catch (Throwable t) {
    if (type.isInstance(t)) return;
    throw new AssertionError(message + ": wrong exception " + t);
}
throw new AssertionError(message + ": expected exception " + type.getSimpleName());
}
}

code/locking-isolation-deep-dive-lab/
├── src/main/java/com/example/lockdeepdive/
│ ├── inventory/ Lost Update, Optimistic Locking
│ ├── isolation/ Read Committed vs Repeatable Read
│ ├── locking/ RowLockManager, Pessimistic Locking
│ ├── deadlock/ deterministische Deadlock-Simulation
│ └── demo/ Demo Runner
├── src/test/java/ Kapitel2TestRunner
└── docs/ Design Patterns und ADRs

javac --release 21 -d target/classes $(find src/main/java src/test/java -name "*.java")
java -cp target/classes com.example.lockdeepdive.demo.Kapitel2Demo
java -cp target/classes com.example.lockdeepdive.Kapitel2TestRunner