【List篇】ArrayList 的线程不安全介绍

news2025/3/12 9:40:09

ArrayList 为什么线程不安全？

主要原因是ArrayList是非同步的,没有同步机制,并且其底层实现是基于数组，而数组的长度是固定的。当对 ArrayList 进行增删操作时，需要改变数组的长度，这就会导致多个线程可能同时操作同一个数组，从而引发线程安全问题。
具体来说，如果多个线程同时对 ArrayList 进行写操作（add、remove 等），可能会导致以下问题：

数据不一致：多个线程同时修改 ArrayList 的元素，可能会导致数据不一致的情况。例如，一个线程正在修改一个元素，而另一个线程正在读取该元素，这时就会出现数据不一致的情况。
索引越界：如果多个线程同时进行添加或删除元素操作，就可能导致索引越界的情况。例如，一个线程正在删除 ArrayList 中最后一个元素，而另一个线程正在向 ArrayList 中添加元素，这时就可能导致索引越界的情况。

/**
 * 模拟ArrayList线程不安全
 */
public class UnsafeArrayList {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        //线程1，添加1000个元素
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                list.add(i);
            }
        });
        //线程2，添加1000个元素
        Thread t2 = new Thread(() -> {
            for (int i = 1000; i < 2000; i++) {
                list.add(i);
            }
        });

        //启动线程
        t1.start();
        t2.start();

        try {
            //等待两个线程执行完毕
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("期望size=2000，实际size=" + list.size());
    }
}

上面的代码中，我们创建了两个线程 t1 和 t2，分别向 ArrayList 中添加了 1000 个元素。但是，由于 ArrayList 不是线程安全的，所以在多线程环境下，两个线程可能会同时访问 ArrayList，导致线程安全问题。
运行上面的代码，结果如下：
在这里插入图片描述

输出结果可能不一定是 2000，可能会小于 2000，这是因为线程之间的操作是交错执行的，有可能一个线程正在添加元素时，另一个线程就已经读取了数组的大小并返回了结果。这样就会导致对数组的修改操作在并发情况下会导致线程竞争和不确定性的结果。

ConcurrentModificationException场景 : 这个异常发生的原因是在迭代集合时，有一个线程对集合进行了修改，并且另一个线程正在运行迭代器，这时就会发生ConcurrentModificationException异常。

为了模拟这个异常，我们可以使用Java的多线程功能。下面是一个简单的示例代码，可以模拟ConcurrentModificationException异常：

public class ConcurrentModificationDemo {
  public static void main(String[] args) {
      //模拟在多线程场景下，由于ArrayList线程不安全引发的ConcurrentModificationException异常场景
      List<Integer> list = new ArrayList<>();
      list.add(1000);
      list.add(2000);
      list.add(3000);
      
      //执行迭代的逻辑
      Runnable task = () -> {
          Iterator<String> iterator = list.iterator();
          while (iterator.hasNext()) {
              String fruit = iterator.next();
              System.out.println(fruit);
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      };

      //线程1执行迭代逻辑
      Thread thread1 = new Thread(task);
      //线程2 插入元素
      Thread thread2 = new Thread(() -> list.add(4000));

      thread1.start();
      thread2.start();
  }
}

在这个示例代码中，我们创建了一个包含三个字符串元素的列表，并使用两个线程来模拟ConcurrentModificationException异常。
一个线程使用列表的迭代器来遍历列表，并在每个元素输出之后休眠1秒。另一个线程在1秒后向列表添加一个新元素。
当第二个线程添加一个新元素时，它会修改列表，而第一个线程仍在使用迭代器遍历列表。因此，当第一个线程尝试访问下一个元素时，就会抛出ConcurrentModificationException异常。
注意，由于多线程环境的不确定性，实际运行结果可能有所不同。
在这里插入图片描述

如何解决ArrayList的线程不安全？

1.使用Collections.synchronizedList方法将ArrayList转换成线程安全的List。该方法返回一个线程安全的List，它会在每个方法调用时同步访问。

List<Integer> syncList = Collections.synchronizedList(new ArrayList<Integer>());

2.使用CopyOnWriteArrayList类来替代ArrayList。CopyOnWriteArrayList是Java并发包中提供的一个线程安全的List，它通过使用写时复制技术（Copy-On-Write）来实现线程安全，每次写操作都会创建一个新的数组，读操作不会加锁，因此性能较高。

List<Integer> copyOnWriteList = new CopyOnWriteArrayList<Integer>();

3.使用Lock或synchronized关键字来保证多个线程对ArrayList的操作同步。可以通过在访问ArrayList的代码块上添加synchronized关键字，或者使用Java并发包中的Lock类来实现同步。但是需要注意，这种方式可能会出现死锁等问题，并且性能也会受到影响。

private static Lock lock = new ReentrantLock();
private static List<Integer> list = new ArrayList<>();

public static void addToArrayList(Integer element) {
    //加锁
    lock.lock();
    try {
        list.add(element);
    } finally {
        //释放锁
        lock.unlock();
    }
}