23.1. The Java Memory Model (JMM)

The Java Memory Model is a part of the Java Language Specification (JLS) that defines how threads communicate through shared memory and how changes made by one thread become visible to others.

• Ensures visibility and ordering of variables.
• Prevents unexpected behavior due to CPU and compiler optimizations.
• Introduced formally in Java 5 (JSR-133) to address shortcomings in earlier models.

The Java Memory Model (JMM) provides a set of rules for how threads interact with memory. Essentially, it describes how changes made by one thread to shared data are communicated to other threads. Three key aspects are covered:

1. Visibility: When one thread changes a variable, those changes can be visible to other threads.
2. Ordering: The sequence in which operations are performed matters. The JMM establishes order in which writes to memory are seen by other threads.
3. Optimizations: Sometimes, the CPU or compiler might rearrange instructions for efficiency, but the JMM ensures that these rearrangements don't lead to incorrect behavior in multi-threaded applications.

The JMM was formally introduced in Java 5 after recognizing issues in the previous designs.

Think of the JMM like a set of traffic rules in a city. Just as traffic rules ensure that cars (threads) can move through intersections (shared memory) smoothly without accidents (unexpected behavior), the JMM ensures that threads interact safely. For instance, if one car signals a change in direction (modifying a variable), other cars can see this signal and adjust their paths accordingly.

• Main Memory and Working Memory:
  • Each thread has its own working memory (like CPU registers/cache).
  • Changes must be flushed to main memory to be visible to other threads.
• Happens-Before Relationship:
  • A set of rules defining the ordering of operations in a multithreaded program.
  • If operation A happens-before operation B, then the effect of A is visible to B.
• Visibility vs. Atomicity vs. Ordering:
  • Visibility: A change made by one thread is seen by another.
  • Atomicity: The operation completes in a single, indivisible step.
  • Ordering: The sequence in which operations are performed.

There are several key concepts within the JMM that help in understanding how threads operate:

1. Main Memory vs. Working Memory: Each thread uses its own working memory (like a cache), which is faster to access than main memory. However, for changes to be seen by other threads, they need to be synchronized and written back to the main memory.
2. Happens-Before Relationship: This is crucial for defining order in multi-threaded programs. If operation A happens before operation B, then B can see the results of A. This relationship is the backbone of ensuring predictable program behavior.
3. Visibility, Atomicity, and Ordering: These three terms represent different aspects of thread interactions:
   • Visibility is about whether changes made by one thread are visible to others.
   • Atomicity refers to operations being completed fully without interruption.
   • Ordering deals with the sequence in which these operations are executed and seen.

Imagine an assembly line in a factory. Each worker (thread) has their own workspace (working memory) where they process parts. When they finish their part of the work, they must pass it to the next worker (flush changes to main memory) to continue building the final product. The happens-before relationship is like a specific order in which tasks must be done. If Worker 1 finishes before Worker 2 starts (happens-before), then Worker 2 knows what parts they have to work with (visibility). But if Worker 2 needs to wait for Worker 1, the entire sequence keeps things organized and efficient.

--