The Java Memory Model (JMM) defines how threads interact with memory, governing visibility, ordering, and atomicity of variable updates across threads. 2. Without proper synchronization, one thread may not see another’s changes due to caching or instruction reordering. 3. The happens-before relationship ensures visibility and ordering, established via program order, locks, volatile variables, thread start/join. 4. Declaring a variable volatile ensures visibility and prevents reordering, making it suitable for flags but not atomic compound operations. 5. Atomic operations like increment require AtomicInteger, synchronized blocks, or locks to prevent race conditions. 6. Synchronized blocks provide mutual exclusion and happens-before guarantees, ensuring safe publication of shared data. 7. Final fields in properly constructed immutable objects are guaranteed to be visible to other threads without additional synchronization. 8. Best practices include using volatile for simple flags, leveraging java.util.concurrent utilities, preferring immutability, and avoiding reliance on intuitive ordering. 9. Always test concurrent code under real multithreaded conditions, as race conditions may not appear in single-threaded execution. 10. Understanding the JMM enables writing correct, predictable concurrent programs by design rather than chance.

When working with Java, especially in concurrent or high-performance applications, understanding the Java Memory Model (JMM) is crucial. It defines how threads interact through memory and what behaviors are legal in multithreaded code. While Java abstracts much of memory management via garbage collection, the JMM governs visibility, ordering, and atomicity of memory operations across threads — and getting it wrong can lead to subtle, hard-to-debug issues like race conditions, stale data, or infinite loops.

Let’s break down the Java Memory Model in practical terms.

What Is the Java Memory Model?

The Java Memory Model is a specification within the Java Language Specification (JLS) that describes how threads interact with memory in a Java application. It doesn’t dictate how memory is laid out (like heap or stack), but rather defines the rules for when changes to variables made by one thread must become visible to others.

Key idea: Without proper synchronization, one thread may not see updates made by another thread — even if those updates happened long ago.

This happens because:

• Each thread may cache variables in CPU registers or local cache.
• The compiler and processor can reorder instructions for optimization (as long as single-threaded semantics are preserved).
• The JMM sets boundaries on these behaviors to allow both performance and predictable concurrency.

The Problem: Visibility and Reordering

Imagine this scenario:

// Shared variables
int value = 0;
boolean ready = false;

// Thread 1
value = 42;
ready = true;

// Thread 2
while (!ready) {
    // spin
}
System.out.println(value); // What gets printed?

You might expect this to print 42. But without synchronization, the JMM allows:

• Thread 2 to never exit the loop (due to caching ready).
• Thread 2 to see ready == true but value == 0 (if writes are reordered or not flushed).
• The compiler to reorder value = 42 and ready = true in Thread 1.

This is where the JMM steps in — by defining happens-before relationships.

Happens-Before: The Core Guarantee

The happens-before relationship is the cornerstone of the JMM. If one action happens-before another, then the first is visible and ordered before the second.

Some key ways to establish happens-before:

• Program order rule: Each thread has a happens-before relationship between actions in the order they appear in code.
• Monitor lock rule: An unlock on a monitor happens-before every subsequent lock on that same monitor.
• Volatile variable rule: A write to a volatile variable happens-before every subsequent read of that same volatile variable.
• Thread start rule: Calling thread.start() happens-before any actions in the started thread.
• Thread join rule: All actions in a thread happen-before the return from that thread’s join().

Back to our example — if we make ready volatile:

volatile boolean ready = false;

Now:

• The write to value happens-before the write to ready (program order).
• The write to ready happens-before the read of ready in Thread 2 (volatile rule).
• Therefore, the read of value in Thread 2 sees the write from Thread 1.

Result: guaranteed to print 42.

Volatile: More Than Just "No Caching"

Many developers think volatile just prevents caching — but it does two things:

1. Ensures visibility: Writes are immediately flushed to main memory, reads are from main memory.
2. Prevents reordering: The JVM and CPU won’t reorder reads/writes around a volatile access.

Specifically:

• Reads of a volatile variable cannot be reordered with any previous read/write.
• Writes of a volatile variable cannot be reordered with any subsequent read/write.

This makes volatile useful for flags and state indicators — but not sufficient for compound operations like count .

Atomicity and Race Conditions

The JMM also defines which operations are atomic.

Guaranteed atomic:

• Reads/writes to int and reference types.
• Reads/writes to volatile long and volatile double (since they’re treated specially).

Not atomic:

• Regular reads/writes to long and double (can be split into two 32-bit operations — though on most modern JVMs, they’re effectively atomic).
• Compound actions like i (read-modify-write), even on int.

So even if a variable is visible, you can still have race conditions:

volatile int counter = 0;

// In multiple threads:
counter  ; // Not atomic! Needs synchronization.

Use AtomicInteger, synchronized, or lock for such cases.

Synchronization and the JMM

synchronized blocks do more than mutual exclusion — they establish happens-before relationships.

When a thread exits a synchronized block:

• All writes before the release of the monitor happen-before the next thread acquiring it.

Example:

Object lock = new Object();
int data = 0;
boolean ready = false;

// Thread 1
synchronized(lock) {
    data = 42;
    ready = true;
}

// Thread 2
synchronized(lock) {
    if (ready) {
        System.out.println(data); // Guaranteed to see 42
    }
}

Even without volatile, the synchronized blocks create a happens-before chain, ensuring visibility.

Final Fields and the JMM

One often-overlooked part of the JMM is how it treats final fields.

Key point: Properly constructed final fields are always visible to other threads without synchronization.

Example:

public class ImmutableObject {
    final int value;
    final String name;

    public ImmutableObject(int value, String name) {
        this.value = value;
        this.name = name;
    }
}

If a thread safely publishes an instance of ImmutableObject (e.g., via a properly constructed list or static field), other threads will see the correct values of value and name — even if the object is shared without synchronization.

But this only works if:

• The reference to the object doesn’t escape during construction.
• The object is effectively immutable or truly immutable.

Practical Takeaways

To write correct concurrent Java code:

• Use volatile for simple flags or status variables.
• Use synchronized, ReentrantLock, or atomic classes for compound operations.
• Prefer immutable objects where possible — they’re thread-safe by design.
• Understand that local variables are thread-safe (each thread has its own stack), but shared objects are not.
• Avoid relying on "intuitive" ordering — use happens-before rules to reason about correctness.

Final Note: Don’t Roll Your Own Synchronization

The JMM is complex, and low-level memory semantics are easy to get wrong. In most cases:

• Use higher-level concurrency utilities from java.util.concurrent: ConcurrentHashMap, AtomicInteger, BlockingQueue, etc.
• Design for immutability and statelessness.
• Test under real concurrency — race conditions often don’t appear in single-threaded tests.

Understanding the JMM won’t eliminate bugs, but it helps you write code that’s correct by design — not by luck.

Basically, it’s the invisible foundation that makes Java concurrency both powerful and perilous.

The above is the detailed content of A Deep Dive into the Java Memory Model. For more information, please follow other related articles on the PHP Chinese website!