volatile Keyword

In a multi-core processor, each core has its own local memory cache. The volatile keyword guarantees that modifications to a variable are immediately visible to all threads, preventing memory visibility issues.

Visibility vs. Atomicity

It is critical to distinguish between these two concepts:

• Visibility: Ensures changes made by one thread to a variable are visible to other threads. volatile guarantees visibility.
• Atomicity: Ensures a set of actions executes as a single, indivisible step. volatile does NOT provide atomicity. For example, volatileCount++ is still not thread-safe.
• Instruction Reordering: The compiler and CPU reorder instructions to optimize execution. volatile establishes a happens-before relationship, preventing reordering around volatile reads/writes.

Code Walkthrough

The following example demonstrates a thread shutdown coordinator using a volatile flag.

public class VolatileFlagDemo {
    private static volatile boolean keepRunning = true;
public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            long count = 0;
            while (keepRunning) {
                count++;
            }
            System.out.println("Worker stopped. Counted: " + count);
        });
worker.start();
        Thread.sleep(1000); // Let worker run for a second
System.out.println("Signaling stop...");
        keepRunning = false; // Directly modifies main memory
        worker.join();
    }
}

Interview-Relevant Information