Javahard

`volatile` vs `synchronized` — what problem does each solve?

Answer

`volatile` guarantees visibility (and ordering) of a variable between threads, but doesn’t make compound operations atomic. `synchronized` provides mutual exclusion and also establishes happens-before (visibility) for the protected code.

class StopFlag {
  private volatile boolean stop = false;

  void requestStop() {
    stop = true;
  }

  void runLoop() {
    while (!stop) {
      // do work
    }
  }
}

Advanced answer

Deep dive

`volatile` solves *visibility*: reads see the latest write (and it adds ordering barriers). It does **not** provide mutual exclusion.
`synchronized` solves *mutual exclusion* (one thread at a time) and also provides happens-before between unlock and subsequent lock.

When to use

`volatile`: simple flags (stop/cancel), publishing a reference, “read-mostly” single-writer patterns.
`synchronized`: protecting invariants across multiple fields and compound operations.

Example pitfall

volatile int count = 0;
count++; // not atomic

Use `AtomicInteger` or `synchronized` for increments.

Common pitfalls

Assuming volatile makes compound operations atomic.
Overusing synchronized on hot paths without considering contention.
Mixing both without understanding the happens-before relationships.