Java volatile: Visibility, Ordering, and Why It's Not Atomic

volatile gives you two guarantees. First, visibility — a write to a volatile variable is immediately visible to reads from other threads. Without volatile, one thread can write a value and another thread might see a stale value forever because the write sits in the writing thread's store buffer or local cache. volatile forces the write to drain to main memory and invalidates other cores' cached copies. Second, ordering — volatile imposes happens-before ordering around the access. The JVM and CPU won't reorder earlier writes to non-volatile fields past a volatile write, or later reads of non-volatile fields before a volatile read. This is crucial for publishing objects safely. What volatile does NOT give you is atomicity for compound operations. volatile int i; i++ is still a bug — i++ is really read, add 1, write, and another thread can read the same value between the read and write. Use AtomicInteger for that; incrementAndGet() uses CAS to make the whole operation atomic. Implementation-wise, on x86 the JVM implements volatile writes with a lock-prefixed instruction that acts as a memory barrier (StoreLoad) — it drains the store buffer and forces a cache coherence cycle. Volatile reads on x86 are essentially free because x86's memory model is already strong enough. On weaker architectures like ARM the barriers matter more and are more expensive. Classic use case: double-checked locking singleton. instance must be volatile. Without it, thread A can see instance as non-null while the object's constructor hasn't finished — because the publishing write of "instance = new Foo()" can be reordered so the reference becomes visible before the fields are initialized. volatile prevents that reordering. When to use volatile vs AtomicXxx vs synchronized: volatile for simple flag / state — "is shutdown requested?" is a classic single-writer, many-reader case. AtomicXxx for counters and compound updates. synchronized for multi-variable invariants or guarded blocks where several fields must move together.