静态内部类实现懒加载最推荐，利用类加载机制保证线程安全与延迟初始化；若需动态创建，可选双重检查锁定（需volatile防止重排序）或concurrenthashmap的computeifabsent实现高效并发控制。
在Java中实现线程安全的懒加载集合，核心在于确保集合只在首次使用时初始化，并且在多线程环境下不会出现重复创建或空指针等问题。常见的场景是单例模式中的实例字段、缓存数据、配置信息等需要延迟加载的集合类型。
使用 synchronized 方法保证线程安全
最简单直接的方式是将懒加载逻辑放在 synchronized 方法中，确保同一时刻只有一个线程能执行初始化操作。
- 方法被 synchronized 修饰后，JVM 保证该方法的原子性和可见性
- 适合低并发场景，高并发下可能成为性能瓶颈
示例代码：
public class LazySafeList {
private List<String> list;
public synchronized List<String> getList() {
if (list == null) {
list = new ArrayList<>();
// 模拟耗时操作
list.add("initialized");
}
return list;
}
}
双重检查锁定（Double-Checked Locking）优化性能
为了减少锁的竞争，可以使用双重检查机制，仅在对象未初始化时加锁，已初始化后直接返回引用。
立即学习“Java免费学习笔记（深入）”；
- 必须将字段声明为 volatile，防止指令重排序导致其他线程拿到未完全构造的对象
- 比 synchronized 方法更高效，适用于高频读取、低频初始化的场景
示例代码：
public class DoubleCheckedLazyList {
private volatile List<String> list;
public List<String> getList() {
if (list == null) {
synchronized (this) {
if (list == null) {
list = new ArrayList<>();
list.add("initialized");
}
}
}
return list;
}
}
利用静态内部类实现懒加载（推荐方式）
Java 类加载机制本身是线程安全的，利用静态内部类的特性可实现“天然线程安全 + 延迟加载”的效果。
- 外部类加载时不创建内部类实例，只有调用时才触发初始化
- JVM 保证类的初始化过程只会执行一次
- 写法简洁，无须手动加锁，性能优秀
示例代码：
public class HolderLazyList {
private static class ListHolder {
static final List<String> LIST = new ArrayList<>();
static {
LIST.add("initialized");
}
}
public List<String> getList() {
return ListHolder.LIST;
}
}
使用 Concurrent 包工具类增强并发能力
如果懒加载集合需要支持动态更新（如缓存），可结合 ConcurrentHashMap 和 computeIfAbsent 方法实现线程安全的延迟加载。
- computeIfAbsent 是原子操作，多个线程同时访问相同 key 时只执行一次初始化
- 适合多 key 场景下的懒加载映射结构
示例代码：
public class ConcurrentLazyCache {
private final ConcurrentHashMap<String, List<String>> cache = new ConcurrentHashMap<>();
public List<String> getOrCreate(String key) {
return cache.computeIfAbsent(key, k -> {
ArrayList<String> list = new ArrayList<>();
list.add("from key: " + k);
return list;
});
}
}
基本上就这些常用方式。选择哪种取决于具体需求：若只是单个集合延迟加载，静态内部类最优雅；若需运行时动态构建，双重检查或 ConcurrentHashMap 更合适。关键是理解每种方案的线程安全机制和适用边界。不复杂但容易忽略细节，比如 volatile 的必要性或类加载时机。
