跳到主要内容
约 8 分钟2 张卡

安全发布

安全发布是指把对象引用交给其他线程时,保证对方拿到引用的同时,也能看到对象在发布前完成的初始化。只把引用赋给一个普通字段做不到这一点:另一个线程可能读到了非空引用,却看到字段还是默认值。单例、配置热加载、监听器注册这类代码都会碰到这个问题。分析这些代码时,需要判断交接方式能否建立可见性,理解构造期间为什么不能让 this 逸出,并分清 final 字段和类初始化各自提供的保证。

1. 面试核心​

先记住这几条,再读正文
  • 线程读到 volatile 引用的新值时,也能看到写入该引用前完成的对象初始化。
  • 构造期间把 this 交给外部代码,会让外部代码提前访问尚未初始化的字段。
  • 对象在构造期间没有逸出时,取得引用的线程能看到 final 字段在构造结束时的值。卡 · 构造期间的 this 逸出
  • 双重检查锁定用锁保证只初始化一次,用 volatile 实例字段向无锁读取者发布构造结果。卡 · 双重检查与静态持有者
  • 安全发布只保证发布前的状态可见,发布后继续修改的共享可变状态仍需同步保护。

2. 未同步发布的问题​

把对象引用赋给共享字段,并不能保证读取者看到初始化结果。下面的 reload() 用普通字段赋值发布新配置:

final class Registry {
private Configuration configuration;

void reload() {
configuration = new Configuration(8080, List.of("api"));
}
}

另一个线程不加同步地读取 configuration,就和 reload() 的写入构成数据竞争:两个线程访问同一个变量,至少一个是写,而它们之间没有任何先后和可见性约定。这时读取者可能读到旧引用,也可能读到新引用;即使读到了新引用,也未必能看到构造器对普通字段的全部写入。原因是编译器和处理器可以重排写入顺序,「写字段」和「写引用」在另一个线程看来不一定按代码顺序发生。

要让引用和初始化结果一起交到读取者手里,可以用以下几种安全发布方式:

  • 在类初始化中创建对象,比如静态字段的初始化。
  • 在同一把锁下写入和读取引用,解锁与随后的加锁之间建立可见性。
  • 通过 volatile 字段或 AtomicReference 这类原子引用交接对象。
  • 通过并发集合或阻塞队列交接对象,它们在文档中声明了内存一致性保证。
  • 在调用 Thread.start() 之前准备好新线程要用的对象。

它们的共同点是在发布者的写入和读取者的读取之间建立 happens-before 关系:前一个操作的结果保证对后一个操作可见。final 字段还有一条独立的初始化保证,第 4 节单独说明。

3. 构造期间的 this 逸出​

this 逸出是指对象还在构造,外部代码就已经拿到了它的引用。外部代码这时调用对象,会读到还没赋值的字段:

public final class Listener {
private final int threshold;

public Listener(EventBus bus) {
bus.register(this); // this 已经可被外部调用
threshold = 10;
}
}

如果 register 立即触发回调,或者把监听器交给另一个线程去分发事件,回调就可能在 threshold = 10 执行之前运行,读到默认值 0。threshold 虽然是 final 字段,但下一节会看到,final 的保证恰恰以构造期间没有逸出为前提,这里帮不上忙。

修复办法是等构造结束再注册:

private Listener() {
threshold = 10;
}

public static Listener create(EventBus bus) {
Listener listener = new Listener();
bus.register(listener);
return listener;
}

这段代码替换原来的公开构造器。工厂方法 create 先完成构造,再注册监听器,回调运行时 threshold 已经赋值。如果事件总线在别的线程上分发回调,还要靠总线内部的同步,把这个构造好的对象安全发布给分发线程。

检查构造器时,留意这几种提前暴露对象的途径:

  • 注册监听器或回调,外部代码直接拿到 this。
  • 启动一个访问当前对象的新线程,新线程可能在构造结束前读取字段。
  • 把 this 放进静态集合,其他代码通过集合取到对象。
  • 调用可被子类重写的方法,子类的实现会在子类字段初始化之前运行。

4. final 字段的初始化安全​

final 字段有一条额外的保证:只要对象在构造期间没有逸出,任何线程拿到它的引用后,都能看到 final 字段在构造结束时的值,即使引用本身是通过数据竞争拿到的。这让正确构造的不可变对象可以更放心地在线程间共享:

public final class Endpoint {
private final String host;
private final int port;

public Endpoint(String host, int port) {
this.host = host;
this.port = port;
}
}

另一个线程拿到正确构造的 Endpoint 后,一定能读到构造器赋给 host 和 port 的值,不会看到 null 或 0。保证还延伸到通过 final 字段能读到的对象或数组:它们在构造结束前写入的内容,同样可见。

但 final 只固定字段本身的值,不会冻结它指向的可变对象:

private final List<String> roles = new ArrayList<>();

这里固定的是 roles 指向哪个列表,列表内容仍然可以增删。构造之后再修改这个列表,新的修改不在 final 的保证范围内,多个线程共享时需要另外同步。要做成真正的不可变对象,还要复制外部传进来的可变数据,并且不再修改任何能从对象上访问到的状态。

5. 双重检查锁定​

双重检查锁定(double-checked locking,DCL)用来延迟创建单例:第一次调用时才创建,创建之后的调用不再加锁。它在锁外和锁内各检查一次:

private static volatile Client instance;

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

这段代码靠两次检查加 volatile 发布,保证只创建一次,并把构造结果安全交给其他线程:

  1. 外层检查发现实例已经存在,直接返回,不用加锁。这是初始化之后最常走的路径。
  2. 多个线程同时在外层读到 null 时,synchronized 让它们依次进入。后进入的线程再检查一次,就会发现前一个线程已经创建了实例,不会重复创建。
  3. 创建者把引用写入 volatile 字段 instance。其他线程在外层读到这个引用时,也能看到 new Client() 里的构造写入。

局部变量 local 保存这次读到的引用,返回时不必再读一次 volatile 字段。示例假设单例创建后一直复用;单例内部的业务状态如果会被修改,仍要单独保证线程安全。

6. 双重检查与静态持有者​

双重检查要同时管两件事:内层锁决定谁来初始化,volatile 让外层的无锁读取者看到构造结果。去掉 volatile 后,锁仍然保证只创建一次,但外层的读取根本没有进入锁,和创建者的写入之间就没有 happens-before 关系。读取者可能拿到非空引用,却看到 Client 的字段还没初始化完。

如果只是想要延迟创建,静态持有者写法更简单,它利用类初始化完成同样的事:

final class Service {
private Service() {}

private static class Holder {
static final Service INSTANCE = new Service();
}

static Service getInstance() {
return Holder.INSTANCE;
}
}

Service 类加载时不会初始化 Holder。第一次调用 getInstance() 读取 Holder.INSTANCE 时,JVM 才触发 Holder 的类初始化。JVM 的类初始化过程会协调并发访问:只让一个线程执行初始化,其他线程等它完成后再使用结果,并且能看到初始化时的写入。所以这里不用手写锁和 volatile,延迟创建和安全发布都由 JVM 保证。

这样得到的单例,范围是加载 Service 的那个类加载器。如果不需要延迟创建,也可以直接用静态字段初始化、枚举单例,或者交给容器管理实例的生命周期。

7. 常见问题​

7.1 字段都是 final,就可以随意共享引用吗?​

不可以。final 的初始化保证有前提:对象构造期间没有逸出。它也只管读取者拿到引用后能看到什么,不管读取者什么时候能拿到新引用;用普通字段交接时,读取者可能一直读到旧引用。字段指向可变对象时,构造后的修改也不在保证内。所以实际交接对象时,仍然应该用第 2 节列出的某种发布方式。

7.2 不可修改视图可以当作不可变快照吗?​

8. 面试题卡片​

先想答案,再翻面先在心里答一遍,再点开卡片对照参考回答。卡片之间可以左右切换,看完会回到这里。
逐张翻看 2 张 →
未标记的卡读完后明天进入复习;已标记的按状态安排

9. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明