What is the difference between volatility and atomicity in the context of multithreaded programming?

volatile guarantees the visibility of variable changes to all threads. When a thread writes a value to a volatile variable, this change becomes immediately visible to other threads. It also prohibits reordering of read and write operations for volatile variables.

Atomic operations (Atomic classes in the java.util.concurrent.atomic package) guarantee that an operation on a variable is performed as a single, indivisible step and cannot be interrupted by another thread. This ensures the correctness of increment, decrement, and Compare-And-Swap operations without using synchronized.

Key difference: volatile only provides visibility but not atomicity of compound operations (for example, i++ - which involves reading, incrementing, and writing). Atomic classes provide both atomicity of individual operations and visibility.

Example:

class VolatileCounter {
    volatile int count = 0;

    public void increment() {
        // This operation is NOT atomic
        count++;
    }
}

class AtomicCounter {
    java.util.concurrent.atomic.AtomicInteger count = new java.util.concurrent.atomic.AtomicInteger(0);

    public void increment() {
        // This operation IS ATOMIC
        count.incrementAndGet();
    }
}