ConcurrentHashMap — Güvenli Map, Güvensiz Sayaç

1
// Velocity check: how many authorisations has this card had in the current window?
2
// A stolen card is often tested with many small payments in a short time.
3
public class BrokenVelocityCounter {
4

5
    private final Map<String, Integer> counts = new ConcurrentHashMap<>();
6

7
    // Each call is thread-safe on its own; the SEQUENCE is not.
8
    // Two threads can both read 7 and both write 8: one attempt is lost.
9
    public void record(String cardToken) {
10
        Integer current = counts.get(cardToken);
11
        counts.put(cardToken, current == null ? 1 : current + 1);
12
    }
13

14
    public long count(String cardToken) {
15
        return counts.getOrDefault(cardToken, 0);
16
    }
17
}

1
public class VelocityCounter {
2

3
    private final ConcurrentMap<String, LongAdder> counts = new ConcurrentHashMap<>();
4

5
    // computeIfAbsent is atomic per key: one LongAdder per card, never two.
6
    // LongAdder spreads increments across cells, so a hot card does not serialize threads.
7
    public void record(String cardToken) {
8
        counts.computeIfAbsent(cardToken, key -> new LongAdder()).increment();
9
    }
10

11
    public long count(String cardToken) {
12
        LongAdder adder = counts.get(cardToken);
13
        return adder == null ? 0 : adder.sum();
14
    }
15

16
    // merge: atomic "put if absent, otherwise combine" for immutable values,
17
    // e.g. the total amount per merchant for the day.
18
    public static void addAmount(ConcurrentMap<String, BigDecimal> totals, String merchantId, BigDecimal amount) {
19
        totals.merge(merchantId, amount, BigDecimal::add);
20
    }
21
}

1
// A payment processor talks to many card-issuing banks; one client per issuer.
2
public class IssuerClientRegistry {
3

4
    private final ConcurrentMap<String, IssuerClient> clients = new ConcurrentHashMap<>();
5

6
    // The mapping function runs while the key's bin is locked: other writers to
7
    // nearby keys wait. Keep it short and never touch the same map inside it.
8
    public IssuerClient forIssuer(String issuerCode) {
9
        IssuerClient existing = clients.get(issuerCode);          // fast path, no locking
10
        if (existing != null) return existing;
11
        return clients.computeIfAbsent(issuerCode, IssuerClient::connect);   // connect() must be quick
12
    }
13
}

1
public class Main {
2

3
    public static void main(String[] args) {
4
        var broken = new BrokenVelocityCounter();
5
        var counter = new VelocityCounter();
6
        String card = "tok_4f9a";                        // a token, never the card number itself
7

8
        try (var pool = Executors.newVirtualThreadPerTaskExecutor()) {
9
            for (int i = 0; i < 10_000; i++) {
10
                pool.submit(() -> {
11
                    broken.record(card);
12
                    counter.record(card);
13
                });
14
            }
15
        }
16

17
        System.out.println("broken:  " + broken.count(card));    // often less than 10000, varies per run
18
        System.out.println("counter: " + counter.count(card));   // always 10000
19
    }
20
}