如何在多线程环境下安全地读取与替换只读列表

本文介绍一种比 synchronized 更轻量、更高效的线程安全方案：使用 volatile 或 AtomicReference 替代同步方法，配合不可变列表（如 List.copyOf()）实现无锁读取与原子更新。

在高并发场景下，频繁调用 synchronized 方法，性能开销和可伸缩性瓶颈会相当明显。你当前的实现中，getFoo() 和 refresh() 都加了 synchronized，但实际需求其实很简单：读操作不修改状态，写操作仅整体替换列表——这正好符合“不可变发布”（immutable publication）模型，完全没必要用重量级锁。

✅ 推荐方案：volatile + 不可变列表

由于 list 只被整体赋值（没有原地修改），而且所有读取都发生在赋值之后，volatile 字段就能提供所需的 happens-before 保证：新列表的构造与发布，对所有线程立即可见。

private volatile List list = List.of(); // 初始化为空不可变列表

public Foo getFoo(Condition condition) {
    // 无需同步：volatile 保证读到最新引用，且列表本身不可变
    for (Foo foo : list) {
        if (condition.check(foo)) {
            return foo;
        }
    }
    return null;
}

public void refresh() {
    // fetchFromDB() 返回新列表；用 List.copyOf() 强制不可变
    List newList = List.copyOf(fetchFromDB());
    list = newList; // volatile 写入，对所有线程立即可见
}

? 注意：List.copyOf()（Ja va 10+）不仅创建不可变副本，还会在运行时检查源列表是否被意外修改（抛出 UnsupportedOperationException），比 Collections.unmodifiableList() 更安全。

? 备选方案：AtomicReference>

如果需要更复杂的原子操作（比如 CAS 更新、条件刷新），可以用 AtomicReference：

private final AtomicReference> listRef = new AtomicReference<>(List.of());

public Foo getFoo(Condition condition) {
    for (Foo foo : listRef.get()) { // get() 具有 volatile 读语义
        if (condition.check(foo)) {
            return foo;
        }
    }
    return null;
}

public void refresh() {
    List newList = List.copyOf(fetchFromDB());
    listRef.set(newList); // set() 具有 volatile 写语义
}

⚠️ 关键注意事项

• 不可变性是前提：list 引用指向的对象必须不可被修改。如果 fetchFromDB() 返回的是可变 ArrayList，务必用 List.copyOf() 或 Collections.unmodifiableList() 封装，否则其他线程在遍历时可能遭遇 ConcurrentModificationException 或数据不一致。
• 元素也需线程安全：Foo 实例自身不应存在共享可变状态；如果内部有状态，要确保其线程安全（比如用 final 字段、不可变设计，或同步访问）。
• 避免隐式修改：千万别把 list 赋值给非 final 可变变量后再修改（比如 List temp = list; temp.add(...)），这会彻底破坏线程安全性。
• 文档即契约：在字段声明旁加上明确注释：

  // Thread-safe: list is volatile and always points to an unmodifiable List.
  // Never mutate the list or its elements after assignment.
  private volatile List list = List.of();

✅ 总结

相比 synchronized，volatile 方案消除了锁竞争，读吞吐量显著提升；再结合 List.copyOf() 确保不可变语义，从根源上杜绝了并发修改风险。这个模式简洁、高效、易测试，可以说是“只读+全量更新”场景下的最佳实践。