락과 CAS 선택 기준

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;

public final class ExpensiveCasUpdate {
    private final AtomicInteger value = new AtomicInteger();
    private final LongAdder calculations = new LongAdder();

    void increment() {
        value.updateAndGet(current -> {
            calculations.increment();
            long checksum = 0;
            for (int i = 0; i < 10_000; i++) {
                checksum += i;
            }
            if (checksum < 0) throw new AssertionError();
            return current + 1;
        });
    }

    public static void main(String[] args) throws InterruptedException {
        ExpensiveCasUpdate demo = new ExpensiveCasUpdate();
        Thread[] workers = new Thread[8];
        for (int i = 0; i < workers.length; i++) {
            workers[i] = Thread.ofPlatform().start(() -> {
                for (int n = 0; n < 1_000; n++) {
                    demo.increment();
                }
            });
        }
        for (Thread worker : workers) {
            worker.join();
        }
        System.out.println("updates=" + demo.value.get());
        System.out.println("calculations=" + demo.calculations.sum());
    }
}

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.locks.ReentrantLock;

public final class LockedSeatInventory {
    record Receipt(String seat, int charged) {}

    private final ReentrantLock lock = new ReentrantLock();
    private final Set<String> available = new HashSet<>(Set.of("A1", "A2"));
    private int revenue;

    Receipt reserve(String seat, int price) {
        if (price <= 0) throw new IllegalArgumentException("price");
        lock.lock();
        try {
            if (!available.remove(seat)) throw new IllegalStateException("unavailable: " + seat);
            revenue = Math.addExact(revenue, price);
            return new Receipt(seat, price);
        } finally {
            lock.unlock();
        }
    }

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

    public static void main(String[] args) throws InterruptedException {
        LockedSeatInventory inventory = new LockedSeatInventory();
        Runnable task = () -> {
            try { System.out.println(inventory.reserve("A1", 120)); }
            catch (IllegalStateException e) { System.out.println("rejected"); }
        };
        Thread a = Thread.ofPlatform().start(task);
        Thread b = Thread.ofPlatform().start(task);
        a.join(); b.join();
        System.out.println("revenue=" + inventory.revenue());
    }
}

import java.util.concurrent.atomic.AtomicReference;

public final class CasSeatCounter {
    record State(int remaining, int revenue) {}
    private final AtomicReference<State> state = new AtomicReference<>(new State(2, 0));

    boolean reserve(int price) {
        while (true) {
            State observed = state.get();
            if (observed.remaining() == 0) return false;
            State candidate = new State(observed.remaining() - 1,
                    Math.addExact(observed.revenue(), price));
            if (state.compareAndSet(observed, candidate)) return true;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        CasSeatCounter counter = new CasSeatCounter();
        Thread a = Thread.ofPlatform().start(() -> counter.reserve(70));
        Thread b = Thread.ofPlatform().start(() -> counter.reserve(80));
        Thread c = Thread.ofPlatform().start(() -> counter.reserve(90));
        a.join();
        b.join();
        c.join();
        System.out.println(counter.state.get());
    }
}