Java中如何将变量值刷新至主内存？单次初始化变量场景

首先得说，你的思路很务实——既然只修改一次，确实没必要用那些专为多线程频繁读写设计的工具。下面给你几个符合需求的方案，按推荐程度排序：

1. 利用线程启动的Happens-Before规则（最省心） #

如果所有后续工作线程都是在主线程把isInitialized设为true之后才启动的，那你什么额外操作都不用做！Java内存模型明确规定：主线程中启动一个线程之前的所有写操作，对该启动后的线程是完全可见的。

举个简单的例子：

private static boolean isInitialized = false;

public static void main(String[] args) {
    // 先完成所有初始化逻辑
    doSomeInitialization();
    isInitialized = true;
    
    // 再启动所有需要读取这个变量的线程
    new Thread(() -> {
        // 这里可以安全地读到isInitialized为true
        if (isInitialized) {
            startWorking();
        }
    }).start();
    
    new Thread(() -> {
        // 这个线程也一样能看到最新值
        while (!isInitialized) {
            // 这里其实不会执行，因为启动前已经设为true了
            Thread.yield();
        }
        doAnotherTask();
    }).start();
}

这种方案零开销，完全依赖JMM的规则，是最优解。

2. 一次性同步块（适合线程已提前启动的场景） #

如果有些线程在初始化完成前就已经在运行了（比如后台守护线程提前启动），那可以用一个简单的同步块来完成内存刷新。同步块的进入和退出会触发内存屏障：写操作在退出同步块时会被强制刷新到主内存，读操作在进入同步块时会从主内存读取最新值。而且因为你只写一次，这个同步的开销几乎可以忽略不计。

示例代码：

private static boolean isInitialized = false;
// 用一个专用的锁对象，避免和其他同步逻辑冲突
private static final Object initLock = new Object();

// 主线程初始化时调用
public static void finishInitialization() {
    synchronized (initLock) {
        isInitialized = true;
        // 同步块退出时，这个写操作会被刷到主内存
    }
}

// 其他线程读取时调用
public static boolean isAppInitialized() {
    synchronized (initLock) {
        return isInitialized;
        // 同步块进入时，会从主内存拉取最新值
    }
}

甚至可以优化一下读取逻辑——如果已经读到true，后续可以直接返回，不用再进同步块：

public static boolean isAppInitialized() {
    // 先做一次无锁读取，如果已经是true就直接返回
    if (isInitialized) {
        return true;
    }
    // 只有读到false时，才进同步块确认最新值
    synchronized (initLock) {
        return isInitialized;
    }
}

这种优化能进一步降低后续读取的开销，毕竟初始化完成后，所有读取都会直接返回true，不会再进入同步块。

3. 底层内存屏障（不推荐，仅作知识补充） #

如果你非要手动触发内存刷新，可以用Unsafe类的storeFence()方法，它会强制把之前的写操作刷新到主内存。但这个方法属于JVM底层API，使用起来不安全，而且不同JVM实现可能有差异，强烈不推荐在生产代码中使用，这里只做演示：

private static boolean isInitialized = false;
private static final Unsafe unsafe;

static {
    // 反射获取Unsafe实例（因为它的构造方法是私有的）
    try {
        Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        unsafeField.setAccessible(true);
        unsafe = (Unsafe) unsafeField.get(null);
    } catch (NoSuchFieldException | IllegalAccessException e) {
        throw new RuntimeException("Failed to get Unsafe instance", e);
    }
}

public static void main(String[] args) {
    isInitialized = true;
    unsafe.storeFence(); // 强制刷新写操作到主内存
}

这种方式完全没必要，前面两种方案已经足够安全且简单，除非你在做底层并发框架开发，否则别碰这个。

内容的提问来源于stack exchange，提问作者Kam