Unlocking Java’s Memory Model: Core Concepts and the Happens‑Before Rule

Java Memory Model Overview

After a series of four detailed blogs, this article provides a compact summary of the Java Memory Model (JMM), which specifies how a thread’s working memory interacts with main memory, guaranteeing visibility and execution order across threads.

Three Core Guarantees

Atomicity: An operation—or a group of operations—must either complete entirely or not at all.

Visibility: When multiple threads access a shared variable, a change made by one thread must become immediately observable by the others.

Ordering: Program actions must appear to execute in the order written in the source code.

In concurrent programming, these three concepts inevitably arise. JMM does not provide a concrete solution for atomicity; it relies on locks or synchronized to achieve it, while it fully addresses visibility and ordering.

Happens‑Before Principle

If the result of operation A must be visible to operation B, then A happens‑before B. This principle is central to determining data races and thread safety. The relationship does not require A to execute before B, only that A’s outcome be visible to B.

Reordering Constraints

Compilers and processors may reorder instructions for efficiency, but they must satisfy two conditions: (1) the program’s final result remains unchanged, and (2) instructions with data dependencies cannot be reordered. Violating these constraints is a primary source of multithreading bugs.

Sequential Consistency Model

Sequential consistency is an idealized reference model that provides strong visibility guarantees. It has two key characteristics:

All operations within a single thread must appear in program order.

All threads must observe a single, global order of operations, with each operation becoming instantly visible to every thread.

Related Blog Posts (for deeper reading)

Java Memory Model – Happens‑Before

Java Memory Model – Reordering

Java Memory Model – Analyzing volatile Java Memory Model – DCL Analysis from JMM Perspective

Recommended References

Cheng Xiaoming: Deep Dive into the Java Memory Model

Zhou Zhimin: Understanding the JVM – Part 5 High‑Performance Concurrency

Java Concurrency Programming: Usage and Principles of volatile Java Concurrency Programming: volatile Keyword Analysis

High‑Concurrency Series (33) – Java Memory Model from a Consistency Perspective (Part 1)

High‑Concurrency Series (34) – Understanding CPU Cache Mechanics (Part 2)

High‑Concurrency Series (35) – Memory Barriers Explained (Part 3)

High‑Concurrency Series (36) – Understanding the Happens‑Before Rule (Part 4)

Plain‑Language Explanation of Happens‑Before