// 錯誤示例：每次調(diào)用都創(chuàng)建新對象
public void processData() {
    List<User> userList = new ArrayList<>(); // 每次進入方法都新建
    // ... 填充 userList 并進行操作
    // 方法結(jié)束，userList 成為垃圾，等待 GC
}

public class BadCache {
    // 靜態(tài)字段，所有線程共享
    private static List<String> sharedList = new ArrayList<>();

    public void addData(String data) {
        sharedList.add(data); // 線程不安全！ArrayList 在并發(fā)修改時會拋出 ConcurrentModificationException 或?qū)е聰?shù)據(jù)錯亂。
    }

    public void clearAndReuse() {
        // 如果只加不減，這個列表會無限增長，最終導(dǎo)致內(nèi)存泄漏！
        // 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); // 每個線程首次使用時創(chuàng)建
            threadLocalList.set(list);
        }
        // ... 使用 list
        // 錯誤：方法結(jié)束后，沒有調(diào)用 threadLocalList.remove()
        // 由于 ThreadLocalMap 的 Key 是弱引用，但 Value 是強引用，會導(dǎo)致 Value 無法被回收，造成內(nèi)存泄漏。
    }
}

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() {
        // 創(chuàng)建代價高的初始化過程
        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) {
        // 歸還對象時，清空內(nèi)容，準備下一次使用
        p.getObject().clear();
    }
}

// 使用
GenericObjectPool<Map<String, Object>> pool = new GenericObjectPool<>(new ExpensiveMapFactory());
Map<String, Object> map = pool.borrowObject(); // 從池中獲取
try {
    // ... 使用 map
} finally {
    pool.returnObject(map); // 務(wù)必在 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); // 惰性創(chuàng)建
            threadLocalList.set(list);
        }
        try {
            // ... 使用 list
        } finally {
            // !!! 關(guān)鍵步驟：使用完畢后，立即清理，防止內(nèi)存泄漏 !!!
            list.clear(); // 清空內(nèi)容，而不是解除 ThreadLocal 綁定
            // 或者 threadLocalList.remove(); // 徹底移除，下次使用會重新創(chuàng)建。對于明確生命周期的場景（如一次請求），remove() 更安全。
        }
    }
}

// 場景1：讀多寫極少，可使用 CopyOnWriteArrayList
private final List<String> readOnlyList = new CopyOnWriteArrayList<>();
// 寫入時會復(fù)制整個底層數(shù)組，所以寫性能差，讀性能極佳且無鎖。

// 場景2：通用的高并發(fā) KV 存儲，使用 ConcurrentHashMap
private final ConcurrentHashMap<String, User> userCache = new ConcurrentHashMap<>();
// 分段鎖/CAS 機制，保證了高并發(fā)下的性能。它本身就是一個“復(fù)用”的容器。

// 場景3：如果需要一個全局復(fù)用的、可更新的列表，但又不想加鎖影響性能，可考慮使用不可變對象。
// 每次更新都創(chuàng)建一個新的 List，然后原子性地替換引用（適用于更新不頻繁的場景）。
private final AtomicReference<List<String>> atomicListRef = new AtomicReference<>(Collections.unmodifiableList(new ArrayList<>()));

public class ReportGenerator {
    // 在生成一份大型報告期間復(fù)用這個列表
    private List<ReportItem> reportItems;

    public void generateReport() {
        this.reportItems = new ArrayList<>(5000); // 在方法開始時創(chuàng)建
        try {
            // ... 填充 reportItems
            // ... 多次使用 reportItems 進行計算和渲染
        } finally {
            // 報告生成完畢，生命周期結(jié)束，可以置為 null 輔助 GC
            // 或者保留，如果下一次 generateReport 能復(fù)用其容量（但通常不建議，邏輯易混淆）
            this.reportItems = null;
        }
    }
}