Race Condition ve Görünürlük

1
// Amounts in kuruş (minor units) as long: exact, and cheap for this demo.
2
public class UnsafeAccount implements Account {
3

4
    private long balance;
5

6
    public UnsafeAccount(long balance) {
7
        this.balance = balance;
8
    }
9

10
    @Override
11
    public boolean withdraw(long amount) {
12
        if (balance >= amount) {        // check ...
13
            balance -= amount;          // ... then act: another thread can run in between,
14
            return true;                // and `balance -= amount` is itself read, subtract, write
15
        }
16
        return false;
17
    }
18

19
    @Override
20
    public long balance() {
21
        return balance;
22
    }
23
}

1
// The shared contract and the two safe versions, in one listing for brevity.
2
interface Account {
3
    boolean withdraw(long amount);
4
    long balance();
5
}
6

7
final class SynchronizedAccount implements Account {
8

9
    private long balance;
10

11
    SynchronizedAccount(long balance) {
12
        this.balance = balance;
13
    }
14

15
    @Override
16
    public synchronized boolean withdraw(long amount) {   // check and act as one step
17
        if (balance < amount) return false;
18
        balance -= amount;
19
        return true;
20
    }
21

22
    @Override
23
    public synchronized long balance() {
24
        return balance;
25
    }
26
}
27

28
final class AtomicAccount implements Account {
29

30
    private final AtomicLong balance;
31

32
    AtomicAccount(long balance) {
33
        this.balance = new AtomicLong(balance);
34
    }
35

36
    @Override
37
    public boolean withdraw(long amount) {
38
        while (true) {
39
            long current = balance.get();
40
            if (current < amount) return false;
41
            // Succeeds only if nobody changed the balance since we read it; otherwise retry.
42
            if (balance.compareAndSet(current, current - amount)) return true;
43
        }
44
    }
45

46
    @Override
47
    public long balance() {
48
        return balance.get();
49
    }
50
}

1
public class TransferIntake implements Runnable {
2

3
    // Set by the end-of-day job at cut-off. Without volatile, this loop may keep
4
    // reading a cached `true` forever and accept transfers into a closed business day.
5
    private volatile boolean accepting = true;
6

7
    @Override
8
    public void run() {
9
        while (accepting) {
10
            Thread.onSpinWait();        // in real code: take the next transfer from a queue
11
        }
12
        System.out.println("cut-off reached, intake stopped");
13
    }
14

15
    public void cutOff() {
16
        accepting = false;
17
    }
18
}

1
public class Main {
2

3
    static final int ATMS = 8;
4
    static final int ATTEMPTS_PER_ATM = 250_000;
5
    static final long OPENING_BALANCE = 1_000_000;   // kuruş
6

7
    public static void main(String[] args) throws Exception {
8
        List<Account> accounts = List.of(new UnsafeAccount(OPENING_BALANCE),
9
                new SynchronizedAccount(OPENING_BALANCE), new AtomicAccount(OPENING_BALANCE));
10
        for (Account account : accounts) {
11
            var approved = new LongAdder();
12
            try (var pool = Executors.newFixedThreadPool(ATMS)) {
13
                for (int t = 0; t < ATMS; t++) {
14
                    pool.submit(() -> {
15
                        for (int i = 0; i < ATTEMPTS_PER_ATM; i++) {
16
                            if (account.withdraw(1)) approved.increment();
17
                        }
18
                    });
19
                }
20
            }   // close() waits for all tasks
21
            System.out.printf("%s: balance %,d, approved %,d (paid out + balance should be %,d)%n",
22
                    account.getClass().getSimpleName(), account.balance(), approved.sum(), OPENING_BALANCE);
23
        }
24
        // 2,000,000 attempts against 1,000,000 kuruş: exactly 1,000,000 may be approved.
25
        // UnsafeAccount: approved + balance != 1,000,000, and it differs every run.
26
        // SynchronizedAccount and AtomicAccount: balance 0, approved 1,000,000.
27

28
        TransferIntake intake = new TransferIntake();
29
        Thread thread = Thread.ofPlatform().start(intake);
30
        Thread.sleep(100);
31
        intake.cutOff();        // with volatile, the loop sees this and exits
32
        thread.join();
33
    }
34
}