Understanding Variable Visibility and the volatile Keyword in Java

This article explains the variable visibility problem in Java multithreading and how the volatile keyword and synchronization can solve it.

Example of the visibility issue:

public class VolatileDemo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        while (true) {
            if (myThread.isTag()) {
                System.out.println("----------");
            }
        }
    }
}

class MyThread extends Thread {
    private boolean tag;
    @Override
    public void run() {
        tag = true;
        System.out.println("子线程中tag为：" + tag);
    }
    public boolean isTag() { return tag; }
}

Because each thread works with its own copy of the variable, the main thread may never see the change made by the child thread.

The article then describes the Java Memory Model (JMM): shared variables are stored in main memory, each thread copies them to its own working memory, and without proper synchronization the copies are not kept consistent.

Solution using a synchronized block:

while (true) {
    synchronized (myThread) {
        if (myThread.isTag()) {
            System.out.println("----------");
        }
    }
}

Synchronization forces a memory barrier, making the updated value visible.

Preferred solution with volatile :

private volatile boolean tag;

When a variable is declared volatile , writes to it happen‑before any subsequent reads, guaranteeing visibility across threads and also preventing instruction reordering.

The article also covers the happens‑before principle, listing its six rules (program order, monitor lock, volatile, transitivity, start, join) and shows how they apply to the examples.

Application in the Singleton pattern:

public class SingletonDemo {
    private static volatile SingletonDemo instance;
    private SingletonDemo() {}
    public static SingletonDemo getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo.class) {
                if (instance == null) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }
}

Marking the instance field as volatile prevents other threads from seeing a partially constructed object.

Additional use‑cases such as a simple trigger mechanism and examples of instruction reordering are also discussed.