Java并发编程——不可变设计

本文最后更新于：3 年前

引言

在多线程编程中，如何保证数据的一致性与安全性往往是一大挑战。不可变对象在这方面提供了一种极其简洁有效的思路：如果一个对象从创建到销毁都不能被修改，那么不同线程之间自然无需为它的读写发生竞争。本文将由浅入深地讲解不可变对象在 Java 中的定义及实现方式，并结合实际应用场景，说明它为何在高并发下能带来显著的安全与性能优势。

定义

不可变对象是指一旦创建后，其内部状态（即成员变量）无法被修改的对象。在 Java 中，实现不可变对象通常需要遵循以下原则：

所有字段为 final：确保字段在构造后不可更改。
类被声明为 final：防止子类修改行为。
不提供修改状态的方法：如 setter 方法。
确保对可变字段的深拷贝：防止通过引用修改内部状态。

示例：

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

并发编程中的优势

线程安全

不可变对象天然线程安全。由于其状态不可更改，多个线程可以安全地共享同一个不可变对象，而无需额外的同步机制。这大大简化了并发编程中的复杂性，避免了竞争条件和数据不一致的问题。

无需同步

传统的可变对象在多线程环境下需要通过 synchronized 关键字或其他同步机制来确保线程安全，而不可变对象则不需要。这不仅减少了代码的复杂性，还提高了性能，因为同步通常会带来额外的开销。

简化缓存和共享

由于不可变对象不可更改，它们可以安全地缓存和共享。例如，Java 的 String 类就是不可变的，这使得字符串常量池的实现成为可能，提升了性能和内存利用率。

避免死锁和竞态条件

使用不可变对象可以避免许多并发编程中常见的问题，如死锁和竞态条件，因为多个线程无法改变对象的状态，从而减少了资源竞争的可能性。

实现

使用 final 关键字

将类声明为 final，防止被继承和修改。将所有字段声明为 private final，确保字段在构造后不可更改。

防御性拷贝

对于包含可变对象的字段，需要在构造方法中进行深拷贝，并在 getter 方法中返回副本，防止外部修改内部状态。

示例：

public final class ImmutablePerson {
    private final String name;
    private final Date birthDate;

    public ImmutablePerson(String name, Date birthDate) {
        this.name = name;
        this.birthDate = new Date(birthDate.getTime()); // 深拷贝
    }

    public String getName() {
        return name;
    }

    public Date getBirthDate() {
        return new Date(birthDate.getTime()); // 返回副本
    }
}

不提供修改方法

不提供任何会修改对象状态的方法，如 setter 方法，确保对象一旦创建后状态不变。

使用不可变集合

Java 提供了一些不可变集合，如 List.of(), Set.of(), Map.of()（自 Java 9 起）。使用这些不可变集合可以确保集合内容在创建后不可更改。

1	`List<String> immutableList = List.of("A", "B", "C");`

应用场景

共享对象

在多线程环境下，可以安全地共享不可变对象，避免每个线程都创建自己的副本，从而节省内存和提升性能。

示例：

public class SharedResource {
    private static final ImmutablePerson PERSON = new ImmutablePerson("Alice", 30);

    public static ImmutablePerson getPerson() {
        return PERSON;
    }
}

多个线程可以调用 SharedResource.getPerson() 安全地获取同一个 ImmutablePerson 实例，而无需担心线程安全问题。

函数式编程

不可变对象是函数式编程的核心，Java 8 引入的函数式接口和流（Streams）等特性鼓励使用不可变设计，提升代码的可读性和可维护性。

示例：

List<String> names = List.of("Alice", "Bob", "Charlie");
List<String> upperCaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

在这个例子中，原始的 names 列表是不可变的，流操作生成的新列表 upperCaseNames 也是不可变的，确保了线程安全。

缓存和备忘录模式

不可变对象适合用于缓存，因为它们可以安全地被多个线程共享而无需同步。例如，Java 的 String 类在实现字符串常量池时就利用了不可变性。

无锁编程

在高性能并发应用中，无锁编程是提升吞吐量的关键技术。不可变对象通过消除对同步的需求，天然支持无锁编程。

示例：使用 AtomicReference 来管理不可变对象

import java.util.concurrent.atomic.AtomicReference;

public class LockFreeCounter {
    private final AtomicReference<ImmutableCounter> counterRef = 
        new AtomicReference<>(new ImmutableCounter(0));

    public void increment() {
        ImmutableCounter current;
        ImmutableCounter updated;
        do {
            current = counterRef.get();
            updated = new ImmutableCounter(current.getValue() + 1);
        } while (!counterRef.compareAndSet(current, updated));
    }

    public int getValue() {
        return counterRef.get().getValue();
    }
}

final class ImmutableCounter {
    private final int value;

    public ImmutableCounter(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

在这个例子中，ImmutableCounter 是不可变的，通过 AtomicReference 实现了线程安全的无锁计数器。

性能考量

减少同步开销

由于不可变对象无需同步机制，避免了因锁竞争带来的性能瓶颈，特别是在高并发场景下，显著提升了系统的吞吐量。

提升缓存命中率

不可变对象可以安全地被缓存和共享，提升了缓存命中率，减少了内存的重复使用。

优化内存管理

由于不可变对象不会改变状态，垃圾回收器可以更高效地管理内存，减少了内存碎片。

增加对象创建的成本

需要注意的是，不可变对象在需要频繁创建新实例的场景下，可能会带来一定的性能开销。因此，在设计时需要权衡不可变性带来的好处与对象创建的成本，比如在读少写多的场景下，不可变设计可能会导致过多实例被创建，带来 GC 压力。

最佳实践

尽量使用现有的不可变类

Java 提供了许多不可变类，如 String、Integer、LocalDate 等，优先使用它们可以减少自定义不可变类的工作量。

合理设计不可变类

确保不可变类的构造方法能够完全初始化所有字段，并避免在构造过程中泄露 this 引用。

结合其他线程安全机制

在某些复杂场景下，可以将不可变对象与 volatile 或 Atomic 类结合使用，以实现更高效的并发控制。

使用不可变集合

尽量使用 Java 提供的不可变集合（如 List.of(), Set.of()），避免手动创建不可变集合，以减少错误。

避免过度使用

虽然不可变对象有诸多优势，但在某些需要频繁修改状态的场景下，过度使用不可变对象可能导致性能下降。因此，应根据具体需求合理选择。

总结

不可变是 Java 并发编程里十分重要的设计思想之一。在多线程环境中，不可变对象具有天然线程安全、无需同步、容易共享等优势，可以显著简化程序逻辑并规避锁竞争、死锁等问题。但与此同时，也要意识到不可变对象在需要高频修改的场景下可能导致额外的对象创建开销。实际系统中，可以将不可变设计与其他并发模式结合使用，以平衡程序的可维护性和性能。通过合理地使用不可变对象（尤其是结合如 AtomicReference 这样的原子类），我们能够写出更简洁、更安全且运行效率更佳的并发程序。

Java并发编程

JavaSE Java并发编程不可变设计

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议，转载请注明出处！

Java并发编程——AQS 上一篇

Java并发编程——无锁下一篇