别再只会用 volatile！JMM 三大核心全解：从根上搞定 Java 并发诡异问题

int a = 1;
int b = a + 1;

int a = 1;
int b = 2;

package com.jam.demo;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * 指令重排问题复现示例
 * @author ken
 * @date 2024
 */
@Slf4j
publicclass ReorderDemo {
    /** 共享变量a */
    privatestaticint a = 0;
    /** 标记变量flag */
    privatestaticboolean flag = false;
    /** 统计重排发生的次数 */
    privatestaticfinal AtomicInteger REORDER_COUNT = new AtomicInteger(0);
    /** 循环执行次数，提高重排发生概率 */
    privatestaticfinalint LOOP_COUNT = 100000;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < LOOP_COUNT; i++) {
            // 每次循环重置状态
            a = 0;
            flag = false;
            CountDownLatch latch = new CountDownLatch(2);

            // 写线程
            Thread writerThread = new Thread(() -> {
                a = 1;
                flag = true;
                latch.countDown();
            });

            // 读线程
            Thread readerThread = new Thread(() -> {
                if (flag) {
                    if (a == 0) {
                        // 进入此分支，说明发生了指令重排：flag=true先执行，a=1后执行
                        REORDER_COUNT.incrementAndGet();
                        log.error("指令重排发生！a={}, flag={}", a, flag);
                    }
                }
                latch.countDown();
            });

            writerThread.start();
            readerThread.start();
            latch.await();
        }

        log.info("循环执行结束，总次数：{}，重排发生次数：{}", LOOP_COUNT, REORDER_COUNT.get());
    }
}

int a = 0;
boolean flag = false;

// 写线程
a = 1;
flag = true;

// 读线程
if (flag) { // 控制依赖
    int b = a + 1;
}

/** 标记变量flag，添加volatile修饰，禁止指令重排 */
private static volatile boolean flag = false;

package com.jam.demo;
import lombok.extern.slf4j.Slf4j;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * VarHandle内存屏障使用示例
 * @author ken
 * @date 2024
 */
@Slf4j
publicclass VarHandleDemo {
    privateint a = 0;
    privateboolean flag = false;
    privatestaticfinal VarHandle A_HANDLE;
    privatestaticfinal VarHandle FLAG_HANDLE;
    privatestaticfinalint LOOP_COUNT = 100000;
    privatestaticfinal AtomicInteger ERROR_COUNT = new AtomicInteger(0);

    // 静态初始化VarHandle，绑定对应的变量
    static {
        try {
            MethodHandles.Lookup lookup = MethodHandles.lookup();
            A_HANDLE = lookup.findVarHandle(VarHandleDemo.class, "a", int.class);
            FLAG_HANDLE = lookup.findVarHandle(VarHandleDemo.class, "flag", boolean.class);
        } catch (ReflectiveOperationException e) {
            thrownew ExceptionInInitializerError(e);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < LOOP_COUNT; i++) {
            VarHandleDemo demo = new VarHandleDemo();
            CountDownLatch latch = new CountDownLatch(2);

            // 写线程，使用release模式写，对应StoreStore屏障
            Thread writerThread = new Thread(() -> {
                A_HANDLE.setRelease(demo, 1);
                FLAG_HANDLE.setRelease(demo, true);
                latch.countDown();
            });

            // 读线程，使用acquire模式读，对应LoadLoad屏障
            Thread readerThread = new Thread(() -> {
                if ((boolean) FLAG_HANDLE.getAcquire(demo)) {
                    if ((int) A_HANDLE.getAcquire(demo) == 0) {
                        ERROR_COUNT.incrementAndGet();
                        log.error("并发问题发生！a={}, flag={}", demo.a, demo.flag);
                    }
                }
                latch.countDown();
            });

            writerThread.start();
            readerThread.start();
            latch.await();
        }

        log.info("循环执行结束，总次数：{}，错误次数：{}", LOOP_COUNT, ERROR_COUNT.get());
    }
}

package com.jam.demo;
/**
 * 错误的DCL单例示例（无volatile）
 * @author ken
 * @date 2024
 */
publicclass WrongDclSingleton {
    privatestatic WrongDclSingleton INSTANCE;

    private WrongDclSingleton() {}

    public static WrongDclSingleton getInstance() {
        if (INSTANCE == null) { // 第一次检查
            synchronized (WrongDclSingleton.class) { // 加锁
                if (INSTANCE == null) { // 第二次检查
                    INSTANCE = new WrongDclSingleton(); // 问题根源
                }
            }
        }
        return INSTANCE;
    }
}

package com.jam.demo;
import io.swagger.v3.oas.annotations.tags.Tag;
/**
 * 正确的DCL单例示例（带volatile）
 * @author ken
 * @date 2024
 */
@Tag(name = "DCL单例", description = "正确的双重检查锁单例实现")
publicclass CorrectDclSingleton {
    /** 单例实例，添加volatile修饰，禁止指令重排 */
    privatestaticvolatile CorrectDclSingleton INSTANCE;

    /** 私有构造函数，防止外部实例化 */
    private CorrectDclSingleton() {}

    /**
     * 获取单例实例
     * @return 单例对象
     */
    public static CorrectDclSingleton getInstance() {
        // 第一次检查，无锁，提高性能
        if (INSTANCE == null) {
            // 加锁，保证原子性
            synchronized (CorrectDclSingleton.class) {
                // 第二次检查，防止多线程同时进入第一次检查后重复实例化
                if (INSTANCE == null) {
                    INSTANCE = new CorrectDclSingleton();
                }
            }
        }
        return INSTANCE;
    }
}

package com.jam.demo;
import lombok.extern.slf4j.Slf4j;
/**
 * 可见性问题复现与解决示例
 * @author ken
 * @date 2024
 */
@Slf4j
publicclass VisibilityDemo {
    /** 停止标记，添加volatile修饰保证可见性 */
    privatestaticvolatileboolean stop = false;

    public static void main(String[] args) throws InterruptedException {
        Thread workerThread = new Thread(() -> {
            int i = 0;
            // 读取stop变量，volatile读保证能看到主线程的修改
            while (!stop) {
                i++;
            }
            log.info("工作线程停止，循环次数：{}", i);
        });

        workerThread.start();
        // 主线程休眠1秒，让工作线程充分运行
        Thread.sleep(1000);
        // 修改stop变量，volatile写保证对工作线程可见
        stop = true;
        log.info("主线程已设置stop为true，等待工作线程停止");
        workerThread.join();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.jam.demo</groupId>
    <artifactId>jmm-demo</artifactId>
    <version>1.0.0</version>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>6.1.5</spring.version>
        <lombok.version>1.18.32</lombok.version>
        <guava.version>33.1.0-jre</guava.version>
        <fastjson2.version>2.0.49</fastjson2.version>
        <mybatis-plus.version>3.5.6</mybatis-plus.version>
        <swagger.version>2.5.0</swagger.version>
    </properties>
    <dependencies>
        <!-- Spring核心工具类 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- Guava集合工具类 -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
        <!-- Fastjson2 -->
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>${fastjson2.version}</version>
        </dependency>
        <!-- MyBatis-Plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <!-- Swagger3 -->
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <version>${swagger.version}</version>
        </dependency>
        <!-- 日志依赖 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>2.0.12</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.5.3</version>
        </dependency>
    </dependencies>
</project>