文章/答案/技术大牛

发布

社区首页 >专栏 >并发设计模式实战系列(12)：不变模式（Immutable Object）

并发设计模式实战系列(12)：不变模式（Immutable Object）

摘星.

发布于 2025-05-20 07:03:58

6000

代码可运行

文章被收录于专栏：博客专享博客专享

运行总次数：0

代码可运行

🌟 大家好，我是摘星！ 🌟

今天为大家带来的是并发设计模式实战系列，第十二章不变模式（Immutable Object），废话不多说直接开始~

一、核心原理深度拆解

1. 不可变性的实现机制

┌───────────────────┐        ┌───────────────────┐
│   Mutable State    │        │  Immutable Object  │
│                   │        │                   │
│  - 可修改字段      │──克隆─>│  - final字段       │
│  - setter方法      │        │  - 无修改方法      │
└───────────────────┘        └───────────────────┘

构造时冻结：所有字段通过构造函数一次性初始化
final双重保障：
- 编译期：final字段禁止重新赋值
- 运行期：反射修改final字段会抛IllegalAccessException

2. 线程安全原理

// 典型不可变类示例
public final class ImmutablePoint {
    private final int x;
    private final int y;
    
    // 唯一初始化机会
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    // 只有getter没有setter
    public int getX() { return x; }
    public int getY() { return y; }
}

无状态变化：对象创建后内部状态永不改变
无竞态条件：读操作不需要同步（因为数据不变）

二、生活化类比：博物馆展品

系统组件	现实类比	核心特性
可变对象	实验室中的文物	可修复、可清洁、需严格保护
不可变对象	展出的文物复制品	观众任意观察，无需防护措施
构造函数	3D扫描复制过程	一次性完成精确复制

安全优势：观众（线程）可以随意查看（读取）展品，无需担心损坏（数据竞争）

三、Java代码实现（生产级Demo）

1. 完整可运行代码

import java.util.*;

// 深度不可变类示例
public final class ImmutablePerson {
    private final String name;
    private final int age;
    private final List<String> hobbies;
    private final Date birthDate;

    // 防御性拷贝构造函数
    public ImmutablePerson(String name, int age, List<String> hobbies, Date birthDate) {
        this.name = name;
        this.age = age;
        this.hobbies = Collections.unmodifiableList(new ArrayList<>(hobbies));
        this.birthDate = new Date(birthDate.getTime()); // Date是可变的，必须拷贝
    }

    // 只有getter方法
    public String getName() { return name; }
    public int getAge() { return age; }
    
    // 返回不可修改视图
    public List<String> getHobbies() {
        return hobbies; 
    }
    
    // 返回防御性拷贝
    public Date getBirthDate() {
        return new Date(birthDate.getTime());
    }

    @Override
    public String toString() {
        return "Person[name=" + name + ", age=" + age + 
               ", hobbies=" + hobbies + ", birth=" + birthDate + "]";
    }

    public static void main(String[] args) {
        List<String> hobbies = Arrays.asList("Reading", "Hiking");
        Date birth = new Date(90, 5, 15); // 1990-06-15
        
        ImmutablePerson person = new ImmutablePerson("Alice", 30, hobbies, birth);
        
        // 尝试修改原始数据
        hobbies.set(0, "Gaming");
        birth.setYear(95);
        
        System.out.println(person); // 输出显示不受影响
    }
}

2. 关键实现技术

// 1. 防御性拷贝（针对可变字段）
this.hobbies = new ArrayList<>(hobbies); 

// 2. 不可修改视图
Collections.unmodifiableList(hobbies);

// 3. 深拷贝日期类
this.birthDate = new Date(birthDate.getTime());

// 4. final类禁止继承
public final class ImmutablePerson {...}

四、横向对比表格

1. 线程安全方案对比

方案	线程安全原理	性能开销	适用场景
synchronized	互斥访问	高	高竞争写操作
volatile	可见性保证	低	单一状态变更
Immutable Object	无状态变化	无	高频读取、配置类数据
CopyOnWrite	写时复制	中	读多写少集合

2. JDK中的不可变类

类名	可变字段处理方式	典型用途
String	内部char数组为final	文本处理
Integer	final int value	数值包装
LocalDateTime	所有字段final	日期时间处理
Collections.emptyList()	无修改方法	空集合占位

五、高级优化技巧

1. 享元模式优化

// 缓存常用实例（如IntegerCache）
private static final ImmutablePerson DEFAULT_USER = 
    new ImmutablePerson("Guest", 0, List.of(), new Date(0));

public static ImmutablePerson defaultUser() {
    return DEFAULT_USER; // 所有线程共享同一个安全实例
}

2. 构建器模式

// 解决构造函数参数过多问题
public static class Builder {
    private String name;
    private int age;
    // ...其他字段
    
    public ImmutablePerson build() {
        return new ImmutablePerson(name, age, hobbies, birthDate);
    }
}

3. 不可变集合进阶

// Java 9的工厂方法创建不可变集合
List<String> hobbies = List.of("Reading", "Hiking");

// Guava的不可变集合
ImmutableList<String> hobbies = 
    ImmutableList.<String>builder().add("Reading").add("Hiking").build();

通过这种原理剖析+生活类比+生产代码+横向对比的解析方式，可以全面掌握不可变对象模式的设计精髓，并能在实际项目中正确应用。

好的！我们继续扩展内容，序号从六开始，深入探讨不可变对象模式的高级特性和工程实践：

六、不可变对象的进阶特性

1. 伪不可变对象的陷阱

// 表面不可变但实际可变的危险案例
public final class DangerousImmutable {
    private final Date date;  // Date本身是可变的
    
    public DangerousImmutable(Date date) {
        this.date = date;  // 错误：未做防御性拷贝
    }
    
    public Date getDate() {
        return date;  // 错误：直接返回可变引用
    }
}

// 攻击方式：
DangerousImmutable obj = new DangerousImmutable(new Date());
obj.getDate().setYear(2025);  // 成功修改"不可变"对象

解决方案：

对所有可变字段进行深拷贝（如new Date(date.getTime())）
返回不可修改视图或拷贝副本

2. 不可变对象的性能优化

对象池化（Flyweight Pattern）

// 缓存常用值对象（适用于小而高频创建的对象）
public class ImmutablePoint {
    private static final Map<String, ImmutablePoint> CACHE = new ConcurrentHashMap<>();
    
    public static ImmutablePoint valueOf(int x, int y) {
        String key = x + "," + y;
        return CACHE.computeIfAbsent(key, k -> new ImmutablePoint(x, y));
    }
    // ...原有实现
}

延迟哈希计算

// 适用于重hashCode()的对象
private volatile int hashCode;  // 注意用volatile保证可见性

@Override
public int hashCode() {
    if (hashCode == 0) {
        int result = 17;
        result = 31 * result + x;
        result = 31 * result + y;
        hashCode = result;
    }
    return hashCode;
}

七、工程实践中的模式变体

1. 部分不可变（Partial Immutability）

// 部分字段可变的"半不可变"设计（需线程安全）
public class SemiImmutable {
    private final String id;      // 永久不可变
    private volatile int counter; // 可变但线程安全
    
    public SemiImmutable(String id) {
        this.id = id;
    }
    
    // 仅允许原子更新
    public void increment() {
        counter++;
    }
}

适用场景：需要跟踪对象访问次数但核心ID不变的场景

2. 建造者模式增强

// 解决多参数构造问题（带校验）
public class ImmutableConfig {
    private final String host;
    private final int port;
    // ...其他字段
    
    public static class Builder {
        private String host;
        private int port;
        
        public Builder host(String host) {
            if (!host.matches("\\d+\\.\\d+\\.\\d+\\.\\d+")) {
                throw new IllegalArgumentException("Invalid host");
            }
            this.host = host;
            return this;
        }
        
        public ImmutableConfig build() {
            return new ImmutableConfig(this);
        }
    }
    
    private ImmutableConfig(Builder builder) {
        this.host = builder.host;
        this.port = builder.port;
    }
}

八、与其他模式的协同应用

1. 不可变对象 + 观察者模式

// 状态变更时生成新对象并通知观察者
public class ImmutableSensorData {
    private final double value;
    private final List<Consumer<ImmutableSensorData>> listeners = new CopyOnWriteArrayList<>();
    
    public ImmutableSensorData update(double newValue) {
        ImmutableSensorData newData = new ImmutableSensorData(newValue);
        listeners.forEach(l -> l.accept(newData));
        return newData;
    }
    
    public void addListener(Consumer<ImmutableSensorData> listener) {
        listeners.add(listener);
    }
}

2. 不可变集合 + 函数式编程

List<ImmutablePerson> people = List.of(
    new ImmutablePerson("Alice", 30),
    new ImmutablePerson("Bob", 25)
);

// 纯函数式处理
List<String> names = people.stream()
    .filter(p -> p.getAge() > 28)
    .map(ImmutablePerson::getName)
    .collect(Collectors.toUnmodifiableList());

九、反模式与注意事项

1. 常见误用案例

反模式	问题描述	正确做法
返回可变对象引用	外部可修改内部状态	返回防御性拷贝
继承不可变类	子类可能破坏不可变性	使用final类
构造函数参数校验缺失	可能构造出无效对象	构造时严格校验

2. 性能权衡场景

不适合场景：
- 高频更新的计数器（如AtomicLong更合适）
- 大规模对象图的频繁修改（考虑Copy-On-Write）
推荐场景：
- 配置信息
- 领域值对象（如Money、Color）
- 并发集合的键对象

十、现代Java中的增强支持

1. Record类的本质不可变性

// Java 14+ record自动实现不可变
public record ImmutablePoint(int x, int y) {
    // 编译器自动生成：
    // 1. final字段
    // 2. 规范构造函数
    // 3. equals/hashCode/toString
}

// 使用示例
ImmutablePoint p = new ImmutablePoint(10, 20);
System.out.println(p.x());  // 自动生成访问方法

2. 不可变集合API演进

Java版本	特性	示例
Java 8	Collections.unmodifiableX	Collections.unmodifiableList(list)
Java 9	List/Set/Map.of	List.of("a", "b")
Java 10	Collectors.toUnmodifiable	stream.collect(Collectors.toUnmodifiableList())