ReentrantLock과 계좌 불변식

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public final class LeakedReentrantLockBug {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Thread owner =
                new Thread(
                        () -> {
                            lock.lock();
                            System.out.println("owner-acquired");
                        },
                        "leaking-owner");
        owner.start();
        owner.join();
        boolean acquired = lock.tryLock(20, TimeUnit.MILLISECONDS);
        System.out.println("owner=" + owner.getState() + ", wrong-auto-release=" + acquired);
        if (acquired) lock.unlock();
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public final class LockedBankAccount {
    private int balance;
    private final Lock lock = new ReentrantLock();

    public LockedBankAccount(int initial) {
        if (initial < 0) throw new IllegalArgumentException("initial");
        balance = initial;
    }

    public boolean withdraw(int amount) {
        lock.lock();
        try {
            if (amount <= 0) throw new IllegalArgumentException("amount");
            if (balance < amount) return false;
            balance -= amount;
            return true;
        } finally {
            lock.unlock();
        }
    }

    public int balance() {
        lock.lock();
        try {
            return balance;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockedBankAccount account = new LockedBankAccount(1000);
        boolean[] result = new boolean[2];
        Thread first = new Thread(() -> result[0] = account.withdraw(800), "lock-a"),
                second = new Thread(() -> result[1] = account.withdraw(800), "lock-b");
        first.start();
        second.start();
        first.join();
        second.join();
        System.out.println(
                "success="
                        + ((result[0] ? 1 : 0) + (result[1] ? 1 : 0))
                        + ", balance="
                        + account.balance());
    }
}

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

public final class LockedInventory {
    private final Map<String, Integer> stock = new LinkedHashMap<>();
    private final ReentrantLock lock = new ReentrantLock();

    public void put(String item, int quantity) {
        if (quantity < 0) throw new IllegalArgumentException();
        lock.lock();
        try {
            stock.put(item, quantity);
        } finally {
            lock.unlock();
        }
    }

    public boolean reserve(String item, int quantity) {
        if (quantity <= 0) throw new IllegalArgumentException();
        lock.lock();
        try {
            int current = stock.getOrDefault(item, 0);
            if (current < quantity) return false;
            stock.put(item, current - quantity);
            return true;
        } finally {
            lock.unlock();
        }
    }

    public Map<String, Integer> snapshot() {
        lock.lock();
        try {
            return Map.copyOf(stock);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockedInventory inventory = new LockedInventory();
        inventory.put("book", 3);
        Thread a = new Thread(() -> System.out.println("a=" + inventory.reserve("book", 2))),
                b = new Thread(() -> System.out.println("b=" + inventory.reserve("book", 2)));
        a.start();
        b.start();
        a.join();
        b.join();
        System.out.println(inventory.snapshot());
    }
}