在Java并发编程中，保证多线程访问共享数据的一致性往往让人头疼。不可变类是一种从设计层面规避线程安全问题的思路：对象一旦创建，其状态就再也不能被修改，所有线程看到的都是同一个稳定快照，因此不需要加锁或volatile修饰。
什么是不可变类
不可变类指的是实例在创建之后，其对外暴露的状态永远不会发生变化。Java语言层面的典型代表有String、Integer、LocalDateTime等。它们没有提供任何修改内部字段的setter方法，并且在构造时就把所有数据固定下来。
要实现一个严格的不可变类，通常需要满足几个条件：类本身用final修饰防止被继承篡改逻辑；所有字段用final且为私有；不提供修改方法；如果字段是引用类型，要么该引用指向的也是不可变对象，要么在构造和获取时做防御性拷贝。下面给出一个基础的不可变坐标类示例。
public final class Point {
private final int x;
private final int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
}
上面的Point类没有setter，字段都是final原生类型，因此它是线程安全的。多个线程同时调用getX或getY不会读到中间状态，也不需要任何同步块。
如果字段是引用类型，比如一个List，就必须小心。直接保存外部传入的List引用会导致外部修改影响到内部状态。正确做法是在构造时拷贝一份，并返回时同样拷贝，或使用不可变集合。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public final class ReadOnlyNames {
private final List<String> names;
public ReadOnlyNames(List<String> input) {
// 防御性拷贝，避免外部修改影响内部
this.names = Collections.unmodifiableList(new ArrayList<>(input));
}
public List<String> getNames() {
// 返回不可变视图，防止调用方修改
return names;
}
}
不可变类为什么能实现线程安全
从Java内存模型角度看，final字段有一个重要保证：在构造方法结束前，final字段的赋值会对其他线程可见，且不会重排序到构造方法之外。这意味着只要对象通过正常方式发布（没有被逸出），其他线程拿到引用时一定能看到完整的、正确的字段值。
与之对比，可变对象如果不用volatile或锁保护，一个线程的写操作对另一个线程可能不可见，或者出现指令重排导致读到半初始化对象。不可变类从根上消灭了写操作，因此也就消灭了可见性与原子性问题。这是一种以设计换安全的策略。
需要注意的是，不可变类必须正确发布。如果构造时把this泄露给别的线程（例如注册监听器时传入自身），就可能让其他线程在对象还没建完时就访问到不完整状态。因此构造方法里不要做复杂的对外回调。
public final class SafePublish {
private final int value;
public SafePublish(int value) {
this.value = value;
// 错误示范：构造中泄露this
// TaskManager.submit(this);
}
}
并发场景中的典型应用
在并发容器和函数式编程里，不可变对象非常常见。例如用不可变配置对象在多线程间共享系统参数：每个线程读取同样的配置，谁也不需要改它，自然无锁。又比如用不可变消息对象在生产者消费者队列中传递，消费者只读取不修改，避免加锁复制。
另一个实用场景是作为ConcurrentHashMap的value。如果value是不可变的，那么put之后其他线程get到的一定是完整对象，后续不需要再同步。如果需要更新，则用replace放入新实例，而不是改旧实例。
import java.util.concurrent.ConcurrentHashMap;
public class ConfigCache {
private final ConcurrentHashMap<String, Config> map = new ConcurrentHashMap<>();
public void update(String key, Config newConfig) {
map.put(key, newConfig);
}
public Config get(String key) {
return map.get(key);
}
}
final class Config {
private final String name;
private final int timeout;
Config(String name, int timeout) {
this.name = name;
this.timeout = timeout;
}
public String getName() { return name; }
public int getTimeout() { return timeout; }
}
当不可变对象字段较多、构造复杂时，可以使用Builder模式。Builder本身是可变的，但build()方法返回的是不可变实例，且构造时一次性拷贝所有参数。这样既方便使用，又保住了线程安全。
public final class User {
private final String id;
private final String name;
private User(Builder b) {
this.id = b.id;
this.name = b.name;
}
public static class Builder {
private String id;
private String name;
public Builder id(String id) { this.id = id; return this; }
public Builder name(String name) { this.name = name; return this; }
public User build() { return new User(this); }
}
}
不可变类的局限与权衡
不可变类并非银弹。每次修改状态都要创建新对象，在高频更新且对象较大的场景下会带来GC压力。此时可以结合写时复制、持久化数据结构，或仅在真正共享的场景使用不可变，局部计算仍用可变对象。
另外，过细的不可变包装可能导致代码啰嗦。实际工程中常把不可变作为模块边界契约：对外暴露不可变视图，内部用可变结构提升性能。例如Collections.unmodifiableList就是典型的边界防护手段。
总结来说，Java并发场景下善用不可变类，可以大幅减少显式锁和并发bug。核心就是让对象在构造后不可改、正确发布、必要时防御性拷贝。理解这一设计思想，比死记线程安全手段更有价值。
Javaimmutable_classthread_safety修改时间：2026-08-02 03:18:28