volatile vs Atomic classes?

• volatile – guarantees that every read fetches from main memory and every write flushes to main memory. Sufficient for simple read/write patterns where the new value does not depend on the old value.
• Atomic classes – provide both visibility and atomicity using hardware CAS (Compare-And-Swap). incrementAndGet(), compareAndSet(), and updateAndGet() are all atomic compound operations.
• Atomic family – AtomicInteger, AtomicLong, AtomicBoolean, AtomicReference, AtomicIntegerArray, LongAdder (striped for high contention), AtomicStampedReference (solves ABA problem).
• Neither is enough – for multi-variable invariants or complex compound operations involving multiple fields, use synchronized or ReentrantLock.

When should you use volatile?

package com.bank.core;

import java.math.BigDecimal;

public class VolatileUseCases {
    // Shutdown flag: one writer, many readers
    private volatile boolean running = true;

    // Latest price: one writer publishes, many readers consume
    private volatile BigDecimal latestPrice = BigDecimal.ZERO;

    // Configuration swap: replace entire immutable config
    private volatile AppConfig config = AppConfig.defaults();

    public void stop() { running = false; }
    public boolean isRunning() { return running; }
}

record AppConfig(String dbUrl, int poolSize) {
    static AppConfig defaults() { return new AppConfig("jdbc:...", 10); }
}

When should you use Atomic classes?

package com.bank.core;

import java.math.BigDecimal;
import java.util.concurrent.atomic.*;

public class AtomicUseCases {
    // Counter: atomic increment
    private final AtomicInteger txnCount = new AtomicInteger(0);

    // Sequence generator: unique trade IDs
    private final AtomicLong tradeSequence = new AtomicLong(0);

    // One-time initialization flag
    private final AtomicBoolean initialized = new AtomicBoolean(false);

    // Immutable reference swap with CAS check
    private final AtomicReference<BigDecimal> maxPrice =
        new AtomicReference<>(BigDecimal.ZERO);

    // High-contention counter: per-thread cells
    private final LongAdder requestCounter = new LongAdder();

    public void recordTransaction(BigDecimal price) {
        txnCount.incrementAndGet();
        requestCounter.increment();

        // Atomic max update
        maxPrice.getAndUpdate(current ->
            price.compareTo(current) > 0 ? price : current);
    }

    public long generateTradeId() {
        return tradeSequence.incrementAndGet();
    }

    public void initOnce() {
        if (initialized.compareAndSet(false, true)) {
            // runs exactly once across all threads
            System.out.println("Initialized!");
        }
    }
}

How do volatile and Atomic compare?

| Feature | volatile | Atomic classes |
|---|---|---|
| Visibility | Yes | Yes |
| Atomicity | No | Yes (CAS-based) |
| Mutual exclusion | No | No |
| Use for flags | Yes | AtomicBoolean also works |
| Use for counters | No (counter++ races) | Yes (incrementAndGet) |
| Use for CAS operations | No | Yes (compareAndSet) |
| Multi-variable invariants | No | No (use synchronized) |
| Performance | Lightest | Light (CAS, no lock) |

What is the decision guide?

• Need only visibility (read/write, no compound op)? Use volatile.
• Need atomic increment or decrement? Use AtomicInteger or AtomicLong.
• Need atomic conditional update (CAS)? Use AtomicXxx.compareAndSet().
• Need high-throughput counter (many threads)? Use LongAdder.
• Need atomic reference swap? Use AtomicReference.
• Need to prevent the ABA problem? Use AtomicStampedReference.
• Need compound operation on multiple variables? Use synchronized.

What should a senior engineer know?

• ABA problem: CAS checks if the value is the same as expected. But another thread may have changed it from A to B and back to A. CAS sees A and succeeds, missing the intermediate change. AtomicStampedReference adds a version stamp to detect ABA.
• VarHandle (Java 9): provides fine-grained memory ordering modes beyond volatile. getOpaque(), getAcquire(), setRelease() offer weaker-than-volatile ordering for performance-sensitive code.
• Contention profiling: use perf stat or JMH to measure CAS retries. If retry rate is high, switch from AtomicLong to LongAdder.