为什么 ArrayList是线程不安全却在开发中被广泛使用？

天天摸鱼的java工程师2025-06-04 10:10

为什么 ArrayList是线程不安全却在开发中被广泛使用？

在 Java 开发中，ArrayList 是最常用的集合类之一。尽管我们知道它不是线程安全的，但在实际项目中却频繁出现。本文将从技术原理、业务场景和代码实现三个层面，详细分析这一现象背后的原因。

一、ArrayList 线程不安全的技术原理

（一）线程安全问题的核心根源：缺乏同步机制

ArrayList 的底层实现是动态数组，其元素添加、删除等操作的核心方法（如add()、remove()）均未使用synchronized关键字修饰，这意味着多个线程同时操作同一 ArrayList 实例时，可能出现数据不一致问题。

示例代码：多线程环境下的元素添加
csharp 复制代码 
/**
 * @author 天天摸鱼的java工程师
 * @time 2025年6月4日
 * 演示多线程环境下ArrayList的线程安全问题
 */
public class ArrayListThreadIssueDemo {
    private static List<String> list = new ArrayList<>();
    public static void main(String[] args) {
        // 创建100个线程，每个线程向list中添加1000个元素
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    list.add("element"); // 多个线程同时调用add方法，无同步保护
                }
            }).start();
        }
        // 等待所有线程执行完毕（此处简化处理，实际需使用CountDownLatch等工具）
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("预期大小：100000，实际大小：" + list.size());
        // 输出结果可能小于100000，因为多线程操作导致元素丢失或数据不一致
    }
}

（二）扩容机制引发的线程安全问题

当 ArrayList 的元素数量超过当前容量时，会触发扩容操作。扩容过程包括计算新容量、创建新数组、复制原数组元素到新数组，最后更新底层数组引用。这一过程在多线程环境下可能引发问题。

扩容核心代码分析
arduino 复制代码 
// ArrayList类中的扩容方法
private void grow(int minCapacity) {
    int oldCapacity = elementData.length; // 获取当前数组容量
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量为原容量的1.5倍
    // 复制原数组元素到新数组，并更新底层数组引用
    elementData = Arrays.copyOf(elementData, newCapacity);
}

多线程风险：若两个线程同时触发扩容，可能导致其中一个线程的扩容结果被覆盖，最终底层数组elementData可能只保留最后一次扩容的结果，中间线程的元素添加操作可能丢失。

（三）迭代器与 modCount 机制的冲突

ArrayList 通过modCount变量记录集合的修改次数，迭代器在遍历时会检查该变量是否被修改。多线程环境下，若一个线程在迭代过程中，另一个线程修改了集合，迭代器会抛出ConcurrentModificationException。

迭代器检查代码
arduino 复制代码 
// ArrayList的迭代器实现（简化版）
private class Itr implements Iterator<E> {
    int expectedModCount = modCount; // 记录迭代开始时的修改次数
    public boolean hasNext() {
        return cursor != size;
    }
    public E next() {
        checkForComodification(); // 检查修改次数是否一致
        // ... 其他逻辑
    }
    final void checkForComodification() {
        if (modCount != expectedModCount) // 若修改次数变化，抛出异常
            throw new ConcurrentModificationException();
    }
}

二、实际开发中广泛使用 ArrayList 的原因

（一）单线程场景占绝大多数

在大多数业务系统中，集合的使用场景属于单线程环境：

  • Web 请求处理：Controller 层接收请求后，在单个线程内处理数据，组装业务对象（如将数据库查询结果存入 ArrayList）。
  • 方法内部逻辑：在某个方法内部创建 ArrayList，完成数据处理后即被销毁，不存在多线程共享问题。

这种情况下，ArrayList 的线程不安全特性完全不会暴露，就像在单车道上行驶的车辆，无需担心对向车道的碰撞风险。

（二）性能优势显著优于线程安全集合

与线程安全的Vector相比，ArrayList 在单线程环境下的性能优势明显：

  1. 无锁设计：ArrayList 的方法未添加synchronized，避免了锁竞争带来的性能损耗。
  1. 高效遍历：使用普通 for 循环遍历 ArrayList 的效率远高于 Vector 的Enumeration迭代器。
性能对比（简化数据）
操作 ArrayList（单线程） Vector（线程安全）
元素添加 O (1)（平均） O (1)（有锁开销）
普通 for 遍历 100ms 130ms

（三）成熟的线程安全解决方案

当确实需要多线程操作集合时，Java 提供了多种安全方案，无需强制使用线程安全的 Vector：

  1. 同步包装器：通过Collections.synchronizedList()将 ArrayList 包装为线程安全集合。
arduino 复制代码 
List<String> safeList = Collections.synchronizedList(new ArrayList<>());
// 使用时需手动同步
synchronized (safeList) {
    safeList.add("element");
}
  1. 写时复制容器：CopyOnWriteArrayList适用于读多写少场景，写操作时复制数组保证线程安全，读操作无锁。
scss 复制代码 
List<String> cowList = new CopyOnWriteArrayList<>();
cowList.add("write"); // 写操作复制数组，性能开销在写时
for (String s : cowList) { // 读操作直接访问原数组，高效安全
    process(s);
}
  1. 手动控制锁范围：通过自定义锁对象，缩小同步代码块范围，平衡安全与性能。
typescript 复制代码 
private static List<String> list = new ArrayList<>();
private static final Object LOCK = new Object(); // 自定义锁对象
public static void safeAdd(String element) {
    synchronized (LOCK) { // 仅在添加元素时加锁
        list.add(element);
    }
}

三、核心代码中的安全与效率平衡

（一）复现线程安全问题的完整代码（带详细注释）

java 复制代码 
/**
 * @author 天天摸鱼的java工程师
 * @time 2025年6月4日
 * 多线程环境下ArrayList元素丢失问题复现
 */
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
public class ArrayListThreadUnsafeDemo {
    private static List<String> list = new ArrayList<>(); // 共享的ArrayList实例
    private static final int THREAD_COUNT = 100; // 线程数量
    private static final int ELEMENT_PER_THREAD = 1000; // 每个线程添加的元素数量
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT); // 用于等待所有线程完成
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < ELEMENT_PER_THREAD; j++) {
                        // 生成唯一字符串并添加到list，模拟多线程并发写
                        list.add(UUID.randomUUID().toString());
                    }
                } finally {
                    latch.countDown(); // 线程完成时减少计数器
                }
            }).start();
        }
        latch.await(); // 等待所有线程完成
        System.out.println("预期元素总数：" + (THREAD_COUNT * ELEMENT_PER_THREAD));
        System.out.println("实际元素总数：" + list.size());
        // 输出结果通常小于100000，证明多线程下元素可能丢失
    }
}

（二）安全使用 ArrayList 的最佳实践代码

1. 使用同步包装器（适合中等并发场景）
java 复制代码 
/**
 * @author 天天摸鱼的java工程师
 * @time 2025年6月4日
 * 通过Collections.synchronizedList实现线程安全
 */
import java.util.Collections;
import java.util.List;
public class SynchronizedListDemo {
    private static List<String> safeList = 
        Collections.synchronizedList(new ArrayList<>()); // 包装为线程安全列表
    public static void addElement(String element) {
        synchronized (safeList) { // 手动对列表加锁，保证操作原子性
            safeList.add(element);
        }
    }
}
2. 使用 CopyOnWriteArrayList（适合读多写少场景）
java 复制代码 
/**
 * @author 天天摸鱼的java工程师
 * @time 2025年6月4日
 * 读多写少场景下的线程安全方案
 */
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class CopyOnWriteDemo {
    private static List<String> cowList = new CopyOnWriteArrayList<>(); // 写时复制列表
    public static void main(String[] args) {
        // 写操作：创建新数组并复制原数据，保证线程安全
        cowList.add("write once");
        // 读操作：直接访问底层数组，无需加锁，效率高
        for (String s : cowList) {
            System.out.println(s);
        }
    }
}

四、总结：理性选择工具的核心逻辑

ArrayList 的广泛使用，本质上是技术选型中场景适配 与性价比的结果：

  1. 场景适配：大多数业务逻辑运行在单线程环境，无需为极低概率的多线程问题付出额外成本。
  1. 性能优先：在单线程场景下，ArrayList 的无锁设计带来显著的性能优势，远超 Vector 等线程安全集合。
  1. 方案灵活：当遇到多线程场景时，Java 生态提供了成熟的解决方案（如同步包装器、写时复制容器），允许开发者按需选择。

理解 ArrayList 的线程安全问题，不是为了避免使用它，而是为了在合适的场景中合理运用，并在需要时采用正确的防护措施。这体现了软件开发中一个重要原则：没有绝对完美的工具，只有针对具体场景的最优解。

相关推荐
三两肉2 小时前
Java 中 ArrayList、Vector、LinkedList 的核心区别与应用场景
java·开发语言·list·集合
yuren_xia2 小时前
Spring Boot中保存前端上传的图片
前端·spring boot·后端
clk66073 小时前
SSM 框架核心知识详解（Spring + SpringMVC + MyBatis）
java·spring·mybatis
JohnYan5 小时前
Bun技术评估 - 04 HTTP Client
javascript·后端·bun
shangjg35 小时前
Kafka 的 ISR 机制深度解析：保障数据可靠性的核心防线
java·后端·kafka
青莳吖6 小时前
使用 SseEmitter 实现 Spring Boot 后端的流式传输和前端的数据接收
前端·spring boot·后端
我的golang之路果然有问题6 小时前
ElasticSearch+Gin+Gorm简单示例
大数据·开发语言·后端·elasticsearch·搜索引擎·golang·gin
Alan3166 小时前
Qt 中，设置事件过滤器（Event Filter）的方式
java·开发语言·数据库
拉不动的猪6 小时前
TS常规面试题1
前端·javascript·面试
小鹭同学_7 小时前
Java基础 Day28 完结篇
java·开发语言·log4j
热门推荐
01从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑02KGG转MP3工具|非KGM文件|解密音频03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04山东大学2024深度学习期末考试回忆05DeepSeek各版本说明与优缺点分析06【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！07VMware虚拟机安装Win7专业版保姆级教程（附镜像包）08wandb使用遇到的一些问题09组基轨迹建模 GBTM的介绍与实现（Stata 或 R）10Coze扣子平台完整体验和实践（附国内和国际版对比）