java 中 synchronized 无法直接利用 final 字段来保证可见性,因为 final 的语义是确保对象引用在构造完成后不可变,而非提供线程间的内存屏障。要实现可见性,必须使用 synchronized 块或 volatile 关键字。如果希望结合两者,正确的做法是将共享状态封装在一个对象中,通过 synchronized 方法或块对该对象进行读写操作,同时将该对象的引用声明为 final,以防止引用本身被替换。

synchronized 如何建立 happens-before 关系
synchronized 通过监视器锁(Monitor)建立 happens-before 关系。当线程 A 释放锁时,会将工作内存中的变量刷新到主内存;当线程 B 获取同一把锁时,会清空工作内存并从主内存重新加载变量。这种机制保证了临界区内的代码执行顺序和变量可见性,与 final 字段的初始化安全性无关。

public class SafeHolder {
private final Object lock = new Object();
private int sharedValue = 0;
public void setValue(int value) {
synchronized (lock) {
sharedValue = value;
}
}
public int getValue() {
synchronized (lock) {
return sharedValue;
}
}
}
上述代码中,lock 是 final 的,确保引用不变,但真正起作用的是 synchronized 块。每次调用 setValue 和 getValue 都会加锁,从而保证 sharedValue 的修改对所有线程可见。
为什么 final 不能替代 synchronized
final 字段的主要作用是防止对象逸出时的构造安全问题,即确保其他线程在引用到达之前不会看到部分初始化的对象。它不提供运行时状态的同步机制。如果仅依赖 final 而不使用 synchronized,多个线程并发读写非 final 变量会导致数据竞争和不可见的中间状态。

public class UnsafeExample {
private final Object ref = new Object(); // final 引用
private int counter = 0; // 非 final 可变状态
public void increment() {
// 错误:没有同步,counter 的可见性无法保证
counter++;
}
public int getCounter() {
return counter;
}
}
在 UnsafeExample 中,尽管 ref 是 final 的,但 counter 的递增操作没有同步保护。线程 A 修改 counter 后,线程 B 可能永远看不到最新值,或者读到过期的值。这证明了 final 字段本身不具备可见性保障能力。
基于 synchronized 块内读取 final 引用的具体行为
在 synchronized 块内部读取 final 引用时,由于 final 字段的语义保证其在构造完成后对所有线程立即可见,因此无需额外同步即可安全读取该引用。然而,引用指向的对象内部的非 final 状态仍需通过 synchronized 或其他手段保证可见性。
public class FinalRefAccess {
private final SharedState state = new SharedState();
public void updateState() {
synchronized (state) {
state.value++; // 对 state 内部状态的修改需同步
}
}
public void printState() {
// 读取 final 引用本身是安全的,无需同步
System.out.println(state.getClass().getName());
// 但读取 state.value 需要同步以保证可见性
synchronized (state) {
System.out.println(state.value);
}
}
}
此示例展示了 final 引用 state 在多线程环境下的正确用法。读取 state 对象本身不需要锁,因为其引用在构造后已稳定。但访问 state.value 时必须加锁,以确保该值的可见性。这种模式结合了 final 的安全性和 synchronized 的可见性保障。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南











