跳到主要内容
约 10 分钟3 张卡

不可变对象

不可变对象是构造完成之后,对外可观察的状态不再变化的对象,String、Integer 都是例子。它们可以在线程间共享,也适合作为 HashMap 的键,因为使用过程中不会被其他调用方改掉。

字段加上 final 并不等于对象不可变。如果外部还持有内部列表或数组的引用,就仍有机会修改内容。理解不可变性,关键是沿着输入和返回值检查:谁还拿着可写引用,能否通过它改变内部状态。语言和 API 以 Java 17、21 为准。

1. 面试核心​

先记住这几条,再读正文
  • final 修饰引用字段时,只固定引用的指向,字段引用的可变对象仍要复制,或者由当前对象独占。
  • 不可变对象通过防御性复制隔离可变的输入和输出,并在构造完成前不让外部取得 this 引用。卡 · final 字段
  • 构造器复制数组输入、getter 返回数组副本,输入和输出两个边界都要隔离。卡 · 复制与校验顺序
  • record 的引用组件是 final,传入可变列表时仍需复制列表,并处理可变元素。
  • 对象正确构造、this 没有提前逸出时,其他线程能看到 final 字段在构造时写入的值。卡 · 线程间共享

2. final 字段​

final 禁止字段被重新赋值,但不会冻结字段指向的对象。下面的 Schedule 直接保存了调用方传入的列表:

public final class Schedule {
private final List<Instant> times;

public Schedule(List<Instant> times) {
this.times = times;
}
}

times 不能再指向另一个列表,可调用方手里还有原来的引用:

List<Instant> source = new ArrayList<>();
Schedule schedule = new Schedule(source);
source.add(Instant.now());

source 和 Schedule.times 指向同一个列表,所以往 source 里加一个时间,日程内部保存的内容也跟着变了。问题出在两边共享了一个可变列表:字段即使是 private final,外部依然有修改这份数据的入口。

3. 输入边界的复制​

防御性复制是通过复制可变对象来隔离修改:保存输入时保留副本,返回内部数据时也按需交出副本。先看输入边界,日程的构造器可以用 List.copyOf 保存列表:

public final class Schedule {
private final List<Instant> times;

public Schedule(List<Instant> times) {
this.times = List.copyOf(times);
}

public List<Instant> times() {
return times;
}
}

List.copyOf 返回一个不可修改的列表,并且拒绝 null 元素。调用方再往原列表里增删元素,times 的结构都不会变。元素 Instant 表示一个时间点,它本身不可变,所以元素引用可以放心共享。

元素是可变对象时,只复制列表就不够了,外部仍能通过元素引用修改内容。这时要把元素也复制一份:

public Snapshot(List<MutablePoint> points) {
this.points = points.stream()
.map(MutablePoint::copy)
.toList();
}

MutablePoint::copy 为每个点创建副本。复制到哪一层,取决于哪些对象外部仍然改得到。对象和它引用的对象、再往下引用的对象合在一起,叫对象图。图里不可变的部分可以共享,可变的部分要么复制,要么由当前对象独占,这样才算切断了外部修改内部状态的路径。

4. 输出边界​

输入复制好了,还要看返回值会不会把内部对象交出去。下面的 getter 直接返回内部数组,调用方拿到后就能改里面的字节:

public byte[] digest() {
return digest;
}

改成返回副本,调用方改的就只是自己那一份:

public byte[] digest() {
return digest.clone();
}

构造时也要 clone 一次,防止传入的数组之后被改。输入和输出两个边界缺一不可:只做输入复制,内部数组会从 getter 漏出去;只做输出复制,调用方可以改它传进来的那个数组。

如果内部保存的是 List.copyOf 的结果,元素又不可变,就可以直接返回这个列表。调用方既改不了列表结构,也改不了元素,每次读取都复制一遍没有必要。

5. 不可变类的条件​

判断一个类是否不可变,要把字段、构造过程和对外方法一起检查。下面七条覆盖了前面讲到的修改入口:

  1. 对象构造后没有修改状态的方法。
  2. 字段私有,必要字段用 final 固定。
  3. 构造期间完成验证,并避免 this 逸出,也就是在构造完成前被外部取得。
  4. 对输入中的可变对象做防御性复制。
  5. 不返回可修改内部状态的引用。
  6. 防止子类增加可变语义,或让构造与方法设计在继承下仍安全。
  7. equals 与 hashCode 基于稳定状态。

第 6 条容易漏掉。如果任何子类都能加入可变状态,那么拿到一个父类型引用时,就没法保证它整体不可变。最直接的做法是把类声明为 final,禁止继承;也可以用私有构造器限制实例的创建,或者用 sealed 层次限定允许的子类。后两种做法仍要逐个确认每个实现都满足不可变契约。

6. record 与可变组件​

record 会为组件自动生成字段、访问器和相等性方法,但它不会替你处理可变组件。下面的 Team 直接保存传入的成员列表:

public record Team(String name, List<User> members) {}

record 的组件字段是 final,members 不能再指向另一个列表,但原列表仍能被外部修改,和第 2 节的 Schedule 是同一个问题。可以在紧凑构造器里复制列表。紧凑构造器是省略参数列表的 record 构造器,用来校验或转换组件值,结束时再把值赋给字段:

public record Team(String name, List<User> members) {
public Team {
Objects.requireNonNull(name, "name");
members = List.copyOf(members);
}
}

复制之后,Team 的成员列表结构是稳定的。但如果 User 本身可变,外部仍能通过共享的用户引用修改成员信息。要让整个 Team 不可变,还得用不可变的用户值,或者在输入和输出时复制用户对象。

7. 不可变对象的更新​

不可变对象不能原地修改,「更新」就是返回一个新值,原对象继续表示旧状态。比如金额相加时创建一个新的 Money:

public Money add(Money other) {
requireSameCurrency(other);
return new Money(amount.add(other.amount), currency);
}

add 先检查币种,再把相加结果放进新对象,原来的金额不变。字段多的对象可以提供 withX 方法返回修改后的新值,或者用 Builder 一次收集多个修改:

Configuration next = current.withTimeout(Duration.ofSeconds(2));

调用方必须接住返回的 next 才能拿到新配置,current 仍然保留原来的超时值。方法名和契约要把这一点写清楚,否则调用方可能以为 current 已经被改了,丢掉返回值。

每次小改动都创建一个新对象,连续改很多次就会反复分配和复制。这种情况下,可以先在单线程里用 Builder 累积修改,最后在 build 时生成一个不可变结果。

8. 线程间共享​

不可变对象构造之后就没有状态写入,多个线程同时读它,不需要用锁来协调修改。final 字段还提供初始化安全保证,也就是其他线程拿到对象引用后,能看到这些字段在构造时写入的值。前提是对象正确构造,this 没有在构造完成前被外部取得。

不过,不可变只解决了对象自身的状态问题,围绕它的操作还要分开看:

  • 替换共享引用时,需要使用 volatile 或 AtomicReference,让其他线程看到新对象。
  • 保存对象的可变集合仍需单独同步,元素不可变只解决元素自身的状态问题。
  • 内部若写入懒加载缓存,缓存字段也需同步;懒加载指第一次使用时才计算并保存结果。
  • 方法若读取远程资源,调用仍会阻塞,不可变状态只解决状态共享问题。
  • 大对象反复更新时,创建新副本仍会消耗时间和内存。

9. 复制成本与替代方案​

复制大数组或大对象图要遍历全部数据,还要给副本分配内存。数据量大到复制成本不能接受时,可以按所有权和共享方式选择替代方案:

  • 明确转移所有权,调用后原持有者放弃读写原引用,只由接收方管理数据。
  • 使用不可变持久化数据结构。这里的持久化指新旧版本共享未变化部分,同时保留旧版本,并非写入磁盘。
  • 用只读接口隐藏修改方法,同时控制实际持有对象的代码,避免它从其他入口修改数据。
  • 在能约束所有修改入口的包内共享数据,在公共 API 边界再复制。
  • 对大型二进制数据使用只读缓冲区。它与原缓冲区共享底层数据,所以原持有者的写入仍会影响读取结果。

这些做法的共同前提是:说清楚数据由谁持有,并且封住其他写入入口。如果只在注释里写「不要修改」,却仍然把可写引用交出去,意外修改是挡不住的。

10. 复制与校验顺序​

构造器要保存可变输入时,应该先复制,再校验复制出来的副本。如果先校验原对象再复制,调用方可以在这两步之间改掉内容,最后保存的值就不是校验通过的那个值。下面的 Digest 同时展示了数组的输入复制、长度校验和输出复制:

public record Digest(byte[] bytes) {
public Digest {
bytes = bytes.clone();
if (bytes.length != 32) {
throw new IllegalArgumentException("expected 32 bytes");
}
}

@Override
public byte[] bytes() {
return bytes.clone();
}
}

紧凑构造器先把 bytes 换成副本,再检查长度是否为 32;覆盖后的访问器 bytes() 返回另一份副本。数组的长度创建后就固定了,所以这个长度检查本身不受元素修改影响;但如果约束涉及字节内容,就必须检查同一份副本,保证检查的和保存的是同一份数据。

record 默认生成的 equals 对数组组件比较的是引用。如果 Digest 需要按字节内容判断相等,就要自己重写 equals 和 hashCode。

复制的那一刻,输入也要保持稳定。如果另一个线程正在写这个数组,副本可能混着不同时间点的值。调用方存在并发写入时,双方要用同一把锁,或者先完成所有权转移再复制。

11. 常见问题​

11.1 unmodifiableList 能隔离原列表的修改吗?​

不能。Collections.unmodifiableList 返回的是原列表的只读视图,和原列表共享数据,原列表变了,视图里也能看到。需要固定列表结构时,用 List.copyOf,或者先复制再包装。

11.2 getter 每次都要复制吗?​

11.3 不可变对象适合作为 HashMap 的键吗?​

11.4 深拷贝怎样处理循环引用?​

12. 面试题卡片​

13. 参考资料​

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