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

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

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

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

ArrayList 的底层实现是动态数组，其元素添加、删除等操作的核心方法（如add()、remove()）均未使用synchronized关键字修饰，这意味着多个线程同时操作同一 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 的元素数量超过当前容量时，会触发扩容操作。扩容过程包括计算新容量、创建新数组、复制原数组元素到新数组，最后更新底层数组引用。这一过程在多线程环境下可能引发问题。

扩容核心代码分析

// 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。

迭代器检查代码

// 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 包装为线程安全集合。

List<String> safeList = Collections.synchronizedList(new ArrayList<>());
// 使用时需手动同步
synchronized (safeList) {
    safeList.add("element");
}

1. 写时复制容器：CopyOnWriteArrayList适用于读多写少场景，写操作时复制数组保证线程安全，读操作无锁。

List<String> cowList = new CopyOnWriteArrayList<>();
cowList.add("write"); // 写操作复制数组，性能开销在写时
for (String s : cowList) { // 读操作直接访问原数组，高效安全
    process(s);
}

1. 手动控制锁范围：通过自定义锁对象，缩小同步代码块范围，平衡安全与性能。

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);
    }
}

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

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

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. 使用同步包装器（适合中等并发场景）

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（适合读多写少场景）

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