// 錯誤示例
List<Integer> list = new ArrayList<>();
ExecutorService pool = Executors.newFixedThreadPool(10);
for (int i = 0; i < 1000; i++) {
    pool.execute(() -> list.add(new Random().nextInt()));
}
// 運行結果可能包含：元素丟失、size值異常、數組越界異常等

Map<String, Integer> map = new HashMap<>();
// 并發(fā)執(zhí)行put操作可能導致：
// 1. JDK7及之前版本：環(huán)形鏈表導致CPU 100%
// 2. JDK8+版本：數據丟失或size計數錯誤
// 3. 迭代時ConcurrentModificationException

Set<Integer> set = new HashSet<>();
// 本質是HashMap的包裝類，所有線程安全問題與HashMap一致
// add()方法并發(fā)調用時可能產生元素丟失

// 使用Collections工具類
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
Map<String, Object> syncMap = Collections.synchronizedMap(new HashMap<>());
// 特征：
// 1. 所有方法使用synchronized同步塊
// 2. 迭代器需要手動同步
// 3. 鎖粒度大，性能較差

// Vector/Hashtable方案
Vector<String> vector = new Vector<>(); 
Hashtable<String, Integer> table = new Hashtable<>();
// 缺點：
// 1. 全表鎖導致吞吐量低
// 2. 已逐漸被并發(fā)容器取代

List<String> cowList = new CopyOnWriteArrayList<>();
// 實現(xiàn)原理：
// 1. 寫操作時復制新數組
// 2. 最終一致性保證
// 適用場景：讀多寫少（如白名單配置）

Map<String, Object> concurrentMap = new ConcurrentHashMap<>();
// JDK8+實現(xiàn)特點：
// 1. 分段鎖升級為CAS+synchronized
// 2. 節(jié)點鎖粒度（鎖單個哈希桶）
// 3. 支持并發(fā)度設置

NavigableMap<String, Integer> skipMap = new ConcurrentSkipListMap<>();
// 特征：
// 1. 基于跳表實現(xiàn)的有序Map
// 2. 無鎖讀取，寫入使用CAS

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

// 錯誤示例：即使使用ConcurrentHashMap仍需同步
if (!map.containsKey(key)) {
    map.put(key, value); // 非原子操作
}
// 正確寫法：
map.putIfAbsent(key, value);

// 使用merge方法實現(xiàn)原子計數
ConcurrentHashMap<String, Long> counterMap = new ConcurrentHashMap<>();
counterMap.merge("key", 1L, Long::sum);