Java 集合框架源码深度拆解：架构选型黄金法则 & 线程安全避坑全攻略

// 默认初始容量
private static final int DEFAULT_CAPACITY = 10;
// 无参构造使用的空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 存储元素的底层数组，transient修饰避免序列化整个空数组
transient Object[] elementData;
// 集合中实际元素的数量
private int size;

// 链表头节点
transient Node<E> first;
// 链表尾节点
transient Node<E> last;
// 链表实际元素数量
transient int size;

// 默认初始容量，必须是2的幂
staticfinalint DEFAULT_INITIAL_CAPACITY = 1 << 4; // 16
// 最大容量
staticfinalint MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子
staticfinalfloat DEFAULT_LOAD_FACTOR = 0.75f;
// 链表转红黑树的阈值
staticfinalint TREEIFY_THRESHOLD = 8;
// 红黑树转回链表的阈值
staticfinalint UNTREEIFY_THRESHOLD = 6;
// 链表转红黑树的最小数组容量
staticfinalint MIN_TREEIFY_CAPACITY = 64;
// 哈希桶数组，长度必须是2的幂
transient Node<K,V>[] table;
// 实际键值对数量
transientint size;
// 扩容阈值，threshold = 容量 * 负载因子
int threshold;
// 负载因子
finalfloat loadFactor;

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

package com.jam.demo.collection.pitfall;

import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.List;

/**
 * ArrayList并发修改异常错误示例
 * @author ken
 */
@Slf4j
publicclass ArrayListModificationPitfall {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add("元素" + i);
        }

        // 错误用法：迭代器遍历中用集合的remove方法
        try {
            for (String s : list) {
                if ("元素5".equals(s)) {
                    list.remove(s);
                }
            }
        } catch (Exception e) {
            log.error("单线程迭代器修改触发并发修改异常", e);
        }
    }
}

package com.jam.demo.collection.pitfall;

import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * ArrayList并发修改异常正确示例
 * @author ken
 */
@Slf4j
publicclass ArrayListModificationCorrect {
    public static void main(String[] args) {
        // 单线程正确用法：使用迭代器的remove方法
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add("元素" + i);
        }
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            if ("元素5".equals(s)) {
                iterator.remove();
            }
        }
        log.info("单线程正确操作后集合：{}", list);

        // 多线程正确用法：使用CopyOnWriteArrayList
        CopyOnWriteArrayList<String> concurrentList = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            concurrentList.add("元素" + i);
        }
        // 遍历过程中修改不会触发异常
        for (String s : concurrentList) {
            if ("元素3".equals(s)) {
                concurrentList.remove(s);
            }
        }
        log.info("多线程正确操作后集合：{}", concurrentList);
    }
}

package com.jam.demo.collection.pitfall;

import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 同步包装类迭代器线程不安全错误示例
 * @author ken
 */
@Slf4j
publicclass SynchronizedListPitfall {
    privatestaticfinal List<String> SYNC_LIST = Collections.synchronizedList(new ArrayList<>());
    privatestaticfinal CountDownLatch LATCH = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1000; i++) {
            SYNC_LIST.add("元素" + i);
        }

        // 线程1：遍历集合
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(() -> {
            try {
                for (String s : SYNC_LIST) {
                    // 模拟业务处理
                    Thread.sleep(1);
                }
            } catch (Exception e) {
                log.error("同步包装类遍历触发并发修改异常", e);
            } finally {
                LATCH.countDown();
            }
        });

        // 线程2：修改集合
        executor.execute(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    SYNC_LIST.add("新增元素" + i);
                    Thread.sleep(10);
                }
            } finally {
                LATCH.countDown();
            }
        });

        LATCH.await();
        executor.shutdown();
    }
}

// 正确用法：遍历过程中对集合对象加锁
synchronized (SYNC_LIST) {
    for (String s : SYNC_LIST) {
        // 业务处理
    }
}

package com.jam.demo.collection.pitfall;

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * ConcurrentHashMap复合操作非原子性示例
 * @author ken
 */
@Slf4j
publicclass ConcurrentHashMapAtomicPitfall {
    privatestaticfinal ConcurrentHashMap<String, Integer> COUNT_MAP = new ConcurrentHashMap<>();
    privatestaticfinalint THREAD_COUNT = 100;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        CountDownLatch wrongLatch = new CountDownLatch(THREAD_COUNT);

        // 错误用法：get+put复合操作非原子
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.execute(() -> {
                try {
                    wrongAddCount("test");
                } finally {
                    wrongLatch.countDown();
                }
            });
        }
        wrongLatch.await();
        log.info("错误用法最终计数：{}，预期值：{}", COUNT_MAP.get("test"), THREAD_COUNT);

        // 重置
        COUNT_MAP.clear();
        CountDownLatch correctLatch = new CountDownLatch(THREAD_COUNT);
        // 正确用法：使用原子方法merge
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.execute(() -> {
                try {
                    correctAddCount("test");
                } finally {
                    correctLatch.countDown();
                }
            });
        }
        correctLatch.await();
        log.info("正确用法最终计数：{}，预期值：{}", COUNT_MAP.get("test"), THREAD_COUNT);
        executor.shutdown();
    }

    /**
     * 错误的计数累加方法，get+put非原子操作
     * @param key 计数key
     */
    private static void wrongAddCount(String key) {
        Integer count = COUNT_MAP.get(key);
        count = count == null ? 1 : count + 1;
        COUNT_MAP.put(key, count);
    }

    /**
     * 正确的计数累加方法，使用原子方法merge
     * @param key 计数key
     */
    private static void correctAddCount(String key) {
        COUNT_MAP.merge(key, 1, Integer::sum);
    }
}

package com.jam.demo.collection.pitfall;

import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Arrays.asList坑示例
 * @author ken
 */
@Slf4j
publicclass ArraysAsListPitfall {
    public static void main(String[] args) {
        // 错误用法
        List<String> wrongList = Arrays.asList("a", "b", "c");
        try {
            wrongList.add("d");
        } catch (UnsupportedOperationException e) {
            log.error("Arrays.asList生成的List不支持add操作", e);
        }

        // 正确用法：转换为java.util.ArrayList
        List<String> correctList = new ArrayList<>(Arrays.asList("a", "b", "c"));
        correctList.add("d");
        log.info("正确转换后的List操作成功，当前元素：{}", correctList);
    }
}

// 正确判空：同时判断null和空集合
if (CollectionUtils.isEmpty(list)) {
    log.info("集合为空");
}

// 正确判断非空
if (CollectionUtils.isNotEmpty(list)) {
    log.info("集合非空");
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jam</groupId>
    <artifactId>collection-demo</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>6.1.5</spring.version>
        <lombok.version>1.18.34</lombok.version>
        <guava.version>33.1.0-jre</guava.version>
        <fastjson2.version>2.0.52</fastjson2.version>
        <mybatis-plus.version>3.5.6</mybatis-plus.version>
        <mysql.version>8.4.0</mysql.version>
        <swagger.version>2.5.0</swagger.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>${fastjson2.version}</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>${mysql.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <version>${swagger.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>3.2.5</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>