volatile and Happens-Before in Java Memory Model

Direct Answer

Yes. A write to a volatile field synchronizes-with every subsequent read of that field in the Java Memory Model's synchronization order. Therefore actions before the write happen-before actions after such a read. This supports safe publication protocols, but it does not make unrelated compound updates or a changing multi-field snapshot atomic.

Code Example

public class ConfigLoader {
    private Map<String, String> config;  // not volatile
    private volatile boolean configReady = false;  // volatile flag

    // Thread A: Loader thread
    public void loadConfig() {
        var tempConfig = new HashMap<String, String>();
        tempConfig.put("db.url", "jdbc:postgresql://localhost/app");
        tempConfig.put("db.user", "admin");
        // all these writes happen-before the volatile write below
        config = tempConfig;
        configReady = true;  // volatile write establishes happens-before
    }

    // Thread B: Worker thread
    public String getConfigValue(String key) {
        if (configReady) {  // volatile read
            // guaranteed to see fully initialized config map
            return config.get(key);
        }
        return null;
    }
}

Common Mistakes & Pitfalls

• Thinking only the volatile field is visible: The happens-before guarantee extends to ALL variables written before the volatile write, not just the volatile field itself. Freshers miss this and wonder why volatile is sufficient for safe publication.
• Not understanding the ordering requirement: Happens-before is about ordering — it doesn't mean the write physically happens first in time, but that the effects are ordered in memory such that the read sees them.
• Confusing visibility with synchronization: Happens-before gives you visibility but not atomicity. If you're coordinating multiple writes that must appear atomic to readers, you need synchronized or locks, not just volatile.