java不可变与线程安全吗

在 Java 中，“不可变（Immutable）”通常意味着线程安全，但二者并不是完全等价的概念。下面分层说明。

一、什么是不可变（Immutable）

一个对象在创建之后，其状态（字段值）不能被修改，就是不可变对象。

Java 中典型的不可变类

• String
• Integer、Long 等包装类
• BigDecimal
• 自定义 final class + final 字段 + 不暴露修改方法

不可变对象的特征

public final class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }
}

✅ 字段是 final
✅ 没有 setter
✅ 不返回可变对象的引用（或返回副本）

二、不可变为什么通常是线程安全的？

核心原因

• 多线程读同一个对象
• 对象状态永远不变
• 不需要同步，也不会出现竞态条件

不可变对象可以被多个线程“安全共享”，无需 synchronized 或 volatile

这是《Java 并发编程实战》中的经典结论：

不可变对象永远是线程安全的

三、不可变 ≠ 所有情况都线程安全（注意细节）

1️⃣ 字段是可变对象的引用（常见坑）

public final class BadExample {
    private final List<String> list;

    public BadExample(List<String> list) {
        this.list = list; // 外部仍可修改
    }

    public List<String> getList() {
        return list; // 暴露可变对象
    }
}

❌ 虽然类是 final ❌ 字段是 final ❌ 但 List 是可变的 → 不线程安全

✅ 正确做法：

this.list = new ArrayList<>(list); // 防御性拷贝

或返回不可变集合：

return Collections.unmodifiableList(list);

2️⃣ 构造期间“逸出”（this 逃逸）

public class Unsafe {
    public Unsafe() {
        Thread t = new Thread(() -> {
            System.out.println(this.value);
        });
        t.start();
    }
}

即使对象后来不变，构造过程也可能被其他线程看到不完整状态。

3️⃣ 不可变 ≠ 原子操作

不可变对象本身安全，但对“引用”的更新不是原子的（除非 volatile 或 AtomicReference）。

config = new Config(); // 多线程下读取可能看到旧值

✅ 解决方案：

private volatile Config config;

或

AtomicReference<Config> config;

四、线程安全 ≠ 不可变

线程安全的实现方式不止“不可变”：

五、总结一句话

✅ 不可变对象天然线程安全（前提是真正不可变）
⚠️ 不可变 ≠ 无需考虑共享引用的安全性
⚠️ 线程安全的方式有很多种，不可变只是最安全、最简单的一种

如果你愿意，我也可以：

• 用图示讲“不可变 vs 可变”
• 分析你现有代码是否线程安全
• 讲 String 为什么设计成不可变