java 中利用 volatile 配合 final 字段发布对象,核心在于确保对象的引用可见性以及构造过程中对 final 字段的内存屏障。具体做法是将需要共享的对象封装在一个类中,将其引用声明为 volatile,并在构造函数中初始化该引用的 final 字段。这样,当线程 a 完成对象创建并赋值给 volatile 引用后,线程 b 读取到该引用时,jvm 的内存语义保证能读到 final 字段被正确初始化的值,从而安全地发布对象。

volatile 如何保证 final 字段的可见性
在 Java 内存模型(JMM)中,volatile 变量的写操作会插入一个 StoreStore 屏障和一个 StoreLoad 屏障,读操作会插入一个 LoadLoad 屏障和一个 LoadStore 屏障。对于 final 字段,JLS(Java Language Specification)规定了特殊的内存语义:在构造函数内对 final 字段的写入,在构造函数结束前,其值必须对所有后续读取可见,且不能重排序到构造函数之外。当 volatile 引用被赋值时,这个写操作会强制将之前对 final 字段的修改刷新到主内存;当其他线程读取这个 volatile 引用时,会触发内存屏障,确保从主内存重新加载数据,从而看到 final 字段的最新值。

public class SafePublisher {
// volatile 引用确保发布的可见性
private volatile ObjectHolder holder;
public void publishObject() {
// 构造对象,final 字段在构造期间被安全初始化
ObjectHolder safeHolder = new ObjectHolder(42);
// 将引用赋值给 volatile 变量
// 此写操作会插入内存屏障,确保 final 字段的值对其他线程可见
this.holder = safeHolder;
}
public ObjectHolder getHolder() {
return holder;
}
}
class ObjectHolder {
// final 字段确保一旦初始化后不可变
private final int value;
public ObjectHolder(int value) {
this.value = value;
}
public int getValue() {
return value;
}
}
上述代码中,publishObject 方法创建了一个 ObjectHolder 实例。在构造函数中,this.value = value; 是对 final 字段的写入。随后,this.holder = safeHolder; 是对 volatile 变量的写入。根据 JMM 规则,这个 volatile 写操作会禁止将前面的 final 字段写入重排序到它之后。因此,任何读取到 this.holder 非空值的线程,都能保证看到 value 的正确初始化值。
为什么不用 synchronized 也能安全发布
传统上,我们可能认为需要使用 synchronized 来保护共享状态,但在 final 字段和 volatile 结合的场景下,synchronized 并非必需。这是因为 final 字段的特殊内存语义已经提供了足够的保障。在构造函数中,final 字段的写入不会被重排序到构造函数之外,而 volatile 的写操作又确保了这些写入对其他线程的可见性。这种组合利用了 JMM 对 final 字段的“安全发布”规范,避免了锁的开销,提高了并发性能。需要注意的是,这仅适用于对象本身是不可变的,或者其 final 字段足以保证对象状态的不可变性。
使用Atmosphere构建通过WebSocket、SSE、gRPC、WebTransport、MCP、A2A和AG-UI流传输的JVM代理网关,并带有治理钩子。

// 对比:使用 synchronized 的方式(冗余但安全)
public class SynchronizedPublisher {
private ObjectHolder holder;
public synchronized void publishObject() {
ObjectHolder safeHolder = new ObjectHolder(42);
this.holder = safeHolder;
}
public synchronized ObjectHolder getHolder() {
return holder;
}
}
在 SynchronizedPublisher 中,publishObject 和 getHolder 都被 synchronized 修饰,这通过监视器进入和退出建立了 happens-before 关系,同样保证了安全性。然而,volatile + final 的方式更轻量,因为它只涉及内存屏障,而不涉及线程阻塞或上下文切换。在实际开发中,如果对象是不可变的,优先选择 volatile + final 的方式;如果对象是可变的,则需要额外的同步机制来保护可变状态。
如果 final 字段是引用类型会发生什么
当 final 字段是一个引用类型时,volatile + final 的安全发布仅保证引用本身的可见性和最终性,不保证引用指向的对象内部状态的可见性。也就是说,其他线程能看到这个引用指向了正确的对象实例,但如果该对象内部还有非 final 的可变字段,这些字段的修改对其他线程可能不可见。因此,要完全安全地发布一个对象,该对象必须是真正不可变的,即所有字段都是 final 的,或者对象本身是线程安全的。例如,如果 ObjectHolder 中有一个非 final 的字段 mutableField,那么即使 holder 是 volatile 的,其他线程看到的 mutableField 的值可能是不一致的。
class UnsafeHolder {
private final int immutableValue;
private int mutableValue; // 非 final,线程不安全
public UnsafeHolder(int immutableValue, int mutableValue) {
this.immutableValue = immutableValue;
this.mutableValue = mutableValue;
}
public void setMutableValue(int val) {
this.mutableValue = val;
}
public int getImmutableValue() {
return immutableValue;
}
public int getMutableValue() {
return mutableValue;
}
}
在上述 UnsafeHolder 类中,虽然 immutableValue 是 final 的,可以通过 volatile 引用安全发布,但 mutableValue 不是 final 的。如果线程 A 调用 setMutableValue 修改了 mutableValue,线程 B 可能看不到这个修改,除非使用额外的同步措施。因此,在使用 volatile + final 发布对象时,务必确保对象的所有可变状态都得到妥善保护,或者对象本身是完全不可变的。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南










