Java大对象(如 List、Map)如何复用以及错误和正确的方法讲解

// 错误示例：每次调用都创建新对象
public void processData() {
    List<User> userList = new ArrayList<>(); // 每次进入方法都新建
    // ... 填充 userList 并进行操作
    // 方法结束，userList 成为垃圾，等待 GC
}

public class BadCache {
    // 静态字段，所有线程共享
    private static List<String> sharedList = new ArrayList<>();

    public void addData(String data) {
        sharedList.add(data); // 线程不安全！ArrayList 在并发修改时会抛出 ConcurrentModificationException 或导致数据错乱。
    }

    public void clearAndReuse() {
        // 如果只加不减，这个列表会无限增长，最终导致内存泄漏！
        // sharedList.clear(); // 必须手动清理，但何时清理？清理时机难以把握。
    }
}

public class BadThreadLocalUsage {
    private static final ThreadLocal<List<Object>> threadLocalList = new ThreadLocal<>();

    public void doSomething() {
        List<Object> list = threadLocalList.get();
        if (list == null) {
            list = new ArrayList<>(1000); // 每个线程首次使用时创建
            threadLocalList.set(list);
        }
        // ... 使用 list
        // 错误：方法结束后，没有调用 threadLocalList.remove()
        // 由于 ThreadLocalMap 的 Key 是弱引用，但 Value 是强引用，会导致 Value 无法被回收，造成内存泄漏。
    }
}

public class BadSynchronizedCache {
    private final List<Object> synchronizedList = new ArrayList<>();

    public void add(Object obj) {
        synchronized (this) { // 粗暴的同步，锁粒度太大
            synchronizedList.add(obj);
        }
    }
    // 或者使用 Collections.synchronizedList，但其迭代时仍需手动同步，容易出错。
    // private final List<Object> syncList = Collections.synchronizedList(new ArrayList<>());
}

import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;

public class ExpensiveMapFactory extends BasePooledObjectFactory<Map<String, Object>> {
    @Override
    public Map<String, Object> create() {
        // 创建代价高的初始化过程
        Map<String, Object> map = new HashMap<>();
        for (int i = 0; i < 1000; i++) {
            map.put("key" + i, expensiveInitMethod());
        }
        return map;
    }

    @Override
    public PooledObject<Map<String, Object>> wrap(Map<String, Object> map) {
        return new DefaultPooledObject<>(map);
    }

    @Override
    public void passivateObject(PooledObject<Map<String, Object>> p) {
        // 归还对象时，清空内容，准备下一次使用
        p.getObject().clear();
    }
}

// 使用
GenericObjectPool<Map<String, Object>> pool = new GenericObjectPool<>(new ExpensiveMapFactory());
Map<String, Object> map = pool.borrowObject(); // 从池中获取
try {
    // ... 使用 map
} finally {
    pool.returnObject(map); // 务必在 finally 中归还，否则对象池失效
}

public class GoodThreadLocalUsage {
    private static final ThreadLocal<List<Object>> threadLocalList = new ThreadLocal<>();

    public void doSomething() {
        List<Object> list = threadLocalList.get();
        if (list == null) {
            list = new ArrayList<>(1000); // 惰性创建
            threadLocalList.set(list);
        }
        try {
            // ... 使用 list
        } finally {
            // !!! 关键步骤：使用完毕后，立即清理，防止内存泄漏 !!!
            list.clear(); // 清空内容，而不是解除 ThreadLocal 绑定
            // 或者 threadLocalList.remove(); // 彻底移除，下次使用会重新创建。对于明确生命周期的场景（如一次请求），remove() 更安全。
        }
    }
}

// 场景1：读多写极少，可使用 CopyOnWriteArrayList
private final List<String> readOnlyList = new CopyOnWriteArrayList<>();
// 写入时会复制整个底层数组，所以写性能差，读性能极佳且无锁。

// 场景2：通用的高并发 KV 存储，使用 ConcurrentHashMap
private final ConcurrentHashMap<String, User> userCache = new ConcurrentHashMap<>();
// 分段锁/CAS 机制，保证了高并发下的性能。它本身就是一个“复用”的容器。

// 场景3：如果需要一个全局复用的、可更新的列表，但又不想加锁影响性能，可考虑使用不可变对象。
// 每次更新都创建一个新的 List，然后原子性地替换引用（适用于更新不频繁的场景）。
private final AtomicReference<List<String>> atomicListRef = new AtomicReference<>(Collections.unmodifiableList(new ArrayList<>()));

public class ReportGenerator {
    // 在生成一份大型报告期间复用这个列表
    private List<ReportItem> reportItems;

    public void generateReport() {
        this.reportItems = new ArrayList<>(5000); // 在方法开始时创建
        try {
            // ... 填充 reportItems
            // ... 多次使用 reportItems 进行计算和渲染
        } finally {
            // 报告生成完毕，生命周期结束，可以置为 null 辅助 GC
            // 或者保留，如果下一次 generateReport 能复用其容量（但通常不建议，逻辑易混淆）
            this.reportItems = null;
        }
    }
}