Java Memory Model ve Yeniden Sıralama

1
public class BrokenPublication {
2

3
    static class Tariff {
4
        long eftFee;            // kuruş; not final, not volatile
5
        String version;
6

7
        Tariff() {
8
            eftFee = 650;
9
            version = "2026-10";
10
        }
11
    }
12

13
    static Tariff current;      // plain field: no happens-before between writer and reader
14

15
    static void reload() {      // the admin publishes next month's tariff
16
        current = new Tariff(); // the reference may become visible before eftFee/version are
17
    }
18

19
    static void chargeTransfer() {
20
        Tariff t = current;
21
        if (t != null) {
22
            // Allowed by the JMM: t.eftFee == 0 or t.version == null here.
23
            // In production that is a transfer charged nothing, silently.
24
            System.out.println("fee " + t.eftFee + " (tariff " + t.version + ")");
25
        }
26
    }
27
}

1
// final fields: once the constructor finishes, any thread that sees a reference
2
// to this object sees these values — as long as `this` did not escape during construction.
3
public final class FeeSchedule {
4

5
    private final String version;
6
    private final BigDecimal eftFee;
7
    private final Map<String, BigDecimal> feeBySegment;
8

9
    public FeeSchedule(String version, BigDecimal eftFee, Map<String, BigDecimal> feeBySegment) {
10
        this.version = version;
11
        this.eftFee = eftFee;                          // BigDecimal is immutable itself
12
        this.feeBySegment = Map.copyOf(feeBySegment);  // the map itself must be immutable too
13
    }
14

15
    public String version() { return version; }
16
    public BigDecimal eftFee() { return eftFee; }
17
    public Map<String, BigDecimal> feeBySegment() { return feeBySegment; }
18
}

1
public class LazyBureauClient {
2

3
    // The credit bureau client is expensive to build (TLS, client certificate), so it is
4
    // built on first use. Without volatile, another thread may see a non-null reference
5
    // to a half-constructed client. volatile makes the write happen-before the read.
6
    private volatile HttpClient client;
7

8
    public HttpClient get() {
9
        HttpClient local = client;                    // one volatile read on the fast path
10
        if (local == null) {
11
            synchronized (this) {
12
                local = client;
13
                if (local == null) {
14
                    local = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(2)).build();
15
                    client = local;
16
                }
17
            }
18
        }
19
        return local;
20
    }
21
}

1
public final class CurrencyRegistry {
2

3
    private final Map<String, Currency> byCode;
4

5
    private CurrencyRegistry() {
6
        byCode = Currency.getAvailableCurrencies().stream()
7
                .collect(Collectors.toUnmodifiableMap(Currency::getCurrencyCode, c -> c));
8
    }
9

10
    // Holder idiom: Holder is loaded (and INSTANCE built) on first access to it.
11
    // Class initialization is guaranteed to be thread-safe by the JVM.
12
    private static final class Holder {
13
        static final CurrencyRegistry INSTANCE = new CurrencyRegistry();
14
    }
15

16
    public static CurrencyRegistry instance() {
17
        return Holder.INSTANCE;
18
    }
19

20
    public Optional<Currency> find(String code) {
21
        return Optional.ofNullable(byCode.get(code));
22
    }
23
}

1
// jcstress runs this millions of times on real hardware and reports which
2
// outcomes it saw. Reasoning about reordering by hand is not enough.
3
@JCStressTest
4
@Outcome(id = "650", expect = Expect.ACCEPTABLE, desc = "fully constructed")
5
@Outcome(id = "-1", expect = Expect.ACCEPTABLE, desc = "not yet published")
6
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "published before the fee was written")
7
@State
8
public class PublicationStress {
9

10
    BrokenPublication.Tariff current;
11

12
    @Actor
13
    public void reload() {
14
        current = new BrokenPublication.Tariff();
15
    }
16

17
    @Actor
18
    public void charge(J_Result r) {
19
        BrokenPublication.Tariff t = current;
20
        r.r1 = t == null ? -1 : t.eftFee;
21
    }
22
}