深入拆解Java内存模型：从原子性、可见性到有序性，彻底搞懂happen-before规则

在Java并发编程中，Java内存模型（JMM）是最核心的概念之一。它不仅定义了线程与主内存之间的抽象关系，还为解决并发场景下的原子性、可见性、有序性问题提供了规范保障。理解JMM，是写出正确、高效并发代码的基础。

JMM将内存分为主内存（Main Memory）和工作内存（Working Memory）。主内存是所有线程共享的，存储了实例对象、静态变量等数据；而每个线程都有自己私有的工作内存，存储了该线程使用的变量的主内存副本。线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，不能直接读写主内存。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递需要通过主内存来完成。

原子性是指一个操作是不可分割的，要么全部执行成功，要么全部不执行，执行过程中不会被其他线程打断。

在Java中，对基本数据类型的读取和赋值操作通常是原子性的，但像

这样的复合操作（读取-修改-写入）就不具备原子性。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;

/**
 * 原子性示例
 *
 * @author ken
 */
@Slf4j
public class AtomicityDemo {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        int threadCount = 1000;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 1000; j++) {
                        count++;
                    }
                } finally {
                    countDownLatch.countDown();
                }
            }).start();
        }

        countDownLatch.await();
        log.info("count: {}", count);
    }
}

这段代码启动1000个线程，每个线程对count进行1000次自增操作，预期结果是1000000，但实际运行结果往往小于这个值，因为

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;

/**
 * synchronized保证原子性示例
 *
 * @author ken
 */
@Slf4j
public class SynchronizedAtomicityDemo {
    private static int count = 0;

    private static synchronized void increment() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        int threadCount = 1000;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 1000; j++) {
                        increment();
                    }
                } finally {
                    countDownLatch.countDown();
                }
            }).start();
        }

        countDownLatch.await();
        log.info("count: {}", count);
    }
}

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * AtomicInteger保证原子性示例
 *
 * @author ken
 */
@Slf4j
public class AtomicIntegerDemo {
    private static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        int threadCount = 1000;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 1000; j++) {
                        count.incrementAndGet();
                    }
                } finally {
                    countDownLatch.countDown();
                }
            }).start();
        }

        countDownLatch.await();
        log.info("count: {}", count.get());
    }
}

可见性是指当一个线程修改了共享变量的值，其他线程能立即看到这个修改。

现代CPU通常有多级缓存（L1、L2、L3），每个核心有自己的L1、L2缓存，多个核心共享L3缓存。当线程修改变量时，会先将变量从主内存加载到工作内存（对应CPU缓存），修改后写回主内存，但写回时机不确定，导致其他线程可能看不到最新值。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * 可见性问题示例
 *
 * @author ken
 */
@Slf4j
public class VisibilityDemo {
    private static boolean flag = false;

    public static void main(String[] args) {
        new Thread(() -> {
            while (!flag) {
                // 空循环
            }
            log.info("线程A检测到flag变为true，结束循环");
        }, "线程A").start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("线程中断", e);
        }

        flag = true;
        log.info("主线程将flag设置为true");
    }
}

这段代码中，主线程将flag设置为true后，线程A可能永远不会结束循环，因为线程A的工作内存中flag还是旧值。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * volatile保证可见性示例
 *
 * @author ken
 */
@Slf4j
public class VolatileVisibilityDemo {
    private static volatile boolean flag = false;

    public static void main(String[] args) {
        new Thread(() -> {
            while (!flag) {
                // 空循环
            }
            log.info("线程A检测到flag变为true，结束循环");
        }, "线程A").start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("线程中断", e);
        }

        flag = true;
        log.info("主线程将flag设置为true");
    }
}

有序性是指程序执行的顺序按照代码的先后顺序执行。但在并发场景下，编译器和CPU可能会对指令进行重排序，以提高性能，这可能导致程序执行结果与预期不符。

as-if-serial语义保证：不管怎么重排序，单线程程序的执行结果不能被改变。编译器、runtime和CPU都必须遵守as-if-serial语义。

示例：有序性问题（双重检查锁定）

package com.jam.demo;

/**
 * 双重检查锁定示例（有序性问题）
 *
 * @author ken
 */
public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

如果线程A执行到步骤2，此时instance不为null，但还没初始化对象，线程B在第一次检查时发现instance不为null，直接返回，就会拿到一个未初始化的对象。

package com.jam.demo;

/**
 * 双重检查锁定示例（volatile保证有序性）
 *
 * @author ken
 */
public class VolatileSingleton {
    private static volatile VolatileSingleton instance;

    private VolatileSingleton() {
    }

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

happen-before规则：JMM的核心偏序关系

happen-before规则是JMM定义的一套偏序关系，用于判断两个操作之间是否存在可见性保证。如果操作A happen-before 操作B，那么A的执行结果对B可见，且A的执行顺序排在B之前。

在一个线程内，按照代码顺序，前面的操作happen-before于后面的操作。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * 程序次序规则示例
 *
 * @author ken
 */
@Slf4j
public class ProgramOrderRuleDemo {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int c = a + b;
        log.info("c: {}", c);
    }
}

，所以a和b的赋值对c的计算可见。

一个unlock操作happen-before于后面对同一个锁的lock操作。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * 管程锁定规则示例
 *
 * @author ken
 */
@Slf4j
public class MonitorLockRuleDemo {
    private static int count = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (MonitorLockRuleDemo.class) {
                count = 10;
            }
        }, "线程A").start();

        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.error("线程中断", e);
            }
            synchronized (MonitorLockRuleDemo.class) {
                log.info("count: {}", count);
            }
        }, "线程B").start();
    }
}

线程A先释放锁，线程B后获取锁，所以线程A对count的修改对线程B可见。

对一个volatile变量的写操作happen-before于后面对这个变量的读操作。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * volatile变量规则示例
 *
 * @author ken
 */
@Slf4j
public class VolatileVariableRuleDemo {
    private static volatile int value = 0;
    private static boolean flag = false;

    public static void main(String[] args) {
        new Thread(() -> {
            value = 10;
            flag = true;
        }, "线程A").start();

        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.error("线程中断", e);
            }
            if (flag) {
                log.info("value: {}", value);
            }
        }, "线程B").start();
    }
}

这里flag是volatile变量，线程A对flag的写操作happen-before线程B对flag的读操作，根据传递性，线程A对value的修改对线程B可见。

Thread对象的start()方法happen-before于此线程的每一个动作。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * 线程启动规则示例
 *
 * @author ken
 */
@Slf4j
public class ThreadStartRuleDemo {
    private static int value = 0;

    public static void main(String[] args) {
        value = 10;
        Thread thread = new Thread(() -> {
            log.info("value: {}", value);
        }, "线程A");
        thread.start();
    }
}

主线程对value的修改happen-before线程A的start()方法，线程A的start()方法happen-before线程A的所有动作，所以主线程对value的修改对线程A可见。

线程中的所有操作都happen-before于对此线程的终止检测。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;

/**
 * 线程终止规则示例
 *
 * @author ken
 */
@Slf4j
public class ThreadTerminationRuleDemo {
    private static int value = 0;

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        Thread thread = new Thread(() -> {
            try {
                value = 10;
            } finally {
                countDownLatch.countDown();
            }
        }, "线程A");
        thread.start();
        countDownLatch.await();
        log.info("value: {}", value);
    }
}

线程A的所有操作happen-before主线程对线程A的终止检测（通过CountDownLatch.await()），所以线程A对value的修改对主线程可见。

对线程interrupt()方法的调用happen-before于被中断线程的代码检测到中断事件的发生。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * 线程中断规则示例
 *
 * @author ken
 */
@Slf4j
public class ThreadInterruptRuleDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                // 空循环
            }
            log.info("线程A检测到中断，结束循环");
        }, "线程A");
        thread.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("线程中断", e);
        }

        thread.interrupt();
    }
}

主线程对thread的interrupt()调用happen-before线程A检测到中断事件，所以线程A能正确响应中断。

一个对象的初始化完成happen-before于它的finalize()方法的开始。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * 对象终结规则示例
 *
 * @author ken
 */
@Slf4j
public class ObjectFinalizeRuleDemo {
    private int value;

    public ObjectFinalizeRuleDemo() {
        this.value = 10;
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        log.info("value: {}", value);
    }

    public static void main(String[] args) {
        new ObjectFinalizeRuleDemo();
        System.gc();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("线程中断", e);
        }
    }
}

对象的初始化完成happen-beforefinalize()方法的开始，所以finalize()方法中能看到value的正确值。

如果A happen-before B，B happen-before C，那么A happen-before C。 在volatile变量规则的示例中，线程A对value的修改（A）happen-before线程A对flag的写（B），线程A对flag的写（B）happen-before线程B对flag的读（C），所以线程A对value的修改（A）happen-before线程B对value的读（C）。

JMM通过主内存与工作内存的抽象结构，定义了原子性、可见性、有序性的规范，并通过happen-before规则为并发编程提供了可见性保证。理解JMM的核心概念和规则，是写出正确、高效并发代码的关键。在实际开发中，我们可以通过synchronized、volatile、Lock、原子类等工具，结合happen-before规则，来解决并发场景下的各种问题。

深入拆解 Java 内存模型：从原子性、可见性到有序性，彻底搞懂 happen-before 规则

本文深入解析Java内存模型（JMM），系统阐述原子性、可见性、有序性三大核心问题，结合代码示例剖析典型并发缺陷，并详解happen-before八大规则及其在synchronized、volatile、原子类等场景中的应用，助你夯实并发编程基础。

人工智能

深入解析Java内存模型(JMM)核心概念，详解原子性、可见性、有序性三大特性，剖析happen-before规则及其在并发编程中的应用，帮助开发者掌握synchronized、volatile等关键机制，编写高效线程安全代码。

编译器

Java

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

深入拆解 Java 内存模型：从原子性、可见性到有序性，彻底搞懂 happen-before 规则

深入拆解 Java 内存模型：从原子性、可见性到有序性，彻底搞懂 happen-before 规则

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐