Java 解决 ArrayList 的并发问题

• 1. 场景复现
  • 1.1 数据不一致问题示例代码
  • 1.2 ConcurrentModificationException 问题示例代码
• 2. 解决并发的三种方法
  • 2.1 使用 Collections.synchronizedList
  • 2.2 使用 CopyOnWriteArrayList（推荐使用）
  • 2.3 使用显式的同步控制
• 3. 总结

ArrayList是java.util包中的一个类，它不是线程安全的。如果多个线程同时对同一个ArrayList进行操作，可能会导致并发问题，如数据不一致或ConcurrentModificationException异常。

1. 场景复现

1.1 数据不一致问题示例代码

import java.util.ArrayList;
import java.util.List;

public class ArrayListConcurrencyExample {
    public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<>();

        // 创建并启动多个线程，同时向ArrayList添加元素
        Runnable addTask = () -> {
            for (int i = 0; i < 1000; i++) {
                arrayList.add(i);
            }
        };

        Thread thread1 = new Thread(addTask);
        Thread thread2 = new Thread(addTask);

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

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出ArrayList的大小，不一定是预期的 2000 
        System.out.println("Size of arrayList: " + arrayList.size());
    }
}

1.2 ConcurrentModificationException 问题示例代码

ConcurrentModificationException通常会在迭代ArrayList（或其他集合）的同时对其进行结构性修改时抛出。

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

public class ConcurrentModificationExample {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();

        arrayList.add("Item1");
        arrayList.add("Item2");
        arrayList.add("Item3");

        // 获取迭代器
        Iterator<String> iterator = arrayList.iterator();

        // 开始迭代
        while (iterator.hasNext()) {
            String item = iterator.next();
            System.out.println(item);

            // 在迭代过程中尝试修改ArrayList的结构，会引发ConcurrentModificationException
            if (item.equals("Item2")) {
                arrayList.remove(item);
            }
        }
    }
}

当处理ArrayList的并发问题时，不同的方法有不同的细节和适用场景。以下是对每种方法的详细解释：

2. 解决并发的三种方法

2.1 使用 Collections.synchronizedList

使用 Collections.synchronizedList 创建线程安全的ArrayList这是一种简单的方式来使ArrayList线程安全。它实际上是包装了一个原始的ArrayList，并在每个方法上添加synchronized关键字来确保每个方法在同一时间只能由一个线程访问。

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

这种方法适用于那些多数情况下是读操作，但偶尔需要写操作的情况。请注意，尽管每个方法都是线程安全的，但多个操作之间没有原子性保证，因此还需要其他方式来确保多个操作的一致性。

例如下面的代码就会出现并发问题：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SynchronizedListExample {
    public static void main(String[] args) {
        List<Integer> synchronizedList = Collections.synchronizedList(new ArrayList<>());

        Runnable addAndRemoveTask = () -> {
            for (int i = 0; i < 1000; i++) {
                synchronizedList.add(i);
                synchronizedList.remove(synchronizedList.size() - 1);
            }
        };

        Thread thread1 = new Thread(addAndRemoveTask);
        Thread thread2 = new Thread(addAndRemoveTask);

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

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Size of synchronizedList: " + synchronizedList.size());
    }
}

在这个示例中，两个线程同时执行add和remove操作。虽然每个操作本身是线程安全的，但它们的组合会导致竞态条件，多次运行后，会出现下面的情况：

• 最终列表的大小可能不是预期的 2000。
• 由于两个线程同时进行remove操作，可能导致其中一个线程试图删除一个元素，但在另一个线程之前已经删除了，导致IndexOutOfBoundsException异常或其他不一致的结果

Exception in thread "Thread-0" java.lang.IndexOutOfBoundsException: Index 1 out of bounds for length 1
	at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:64)
	at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckIndex(Preconditions.java:70)
	at java.base/jdk.internal.util.Preconditions.checkIndex(Preconditions.java:248)
	at java.base/java.util.Objects.checkIndex(Objects.java:372)
	at java.base/java.util.ArrayList.remove(ArrayList.java:536)
	at java.base/java.util.Collections$SynchronizedList.remove(Collections.java:2435)
	at com.test.testlist.SynchronizedListExample.lambda$main$0(SynchronizedListExample.java:14)
	at java.base/java.lang.Thread.run(Thread.java:834)
Size of synchronizedList: 1

这突显了Collections.synchronizedList在某些情况下可能无法提供足够的并发保护，因此需要额外的同步措施或选择更适合并发操作的数据结构。

2.2 使用 CopyOnWriteArrayList（推荐使用）

CopyOnWriteArrayList是一种并发集合，它通过在写操作时创建一个新的副本来解决并发问题。这意味着读操作不会受到写操作的影响，而且不会抛出ConcurrentModificationException异常。

   List<String> list = new CopyOnWriteArrayList<>();

这种方法适用于读操作频繁，写操作较少的情况，因为写操作会比较昂贵。但它非常适用于多线程下的读操作，因为它不需要额外的同步。

2.3 使用显式的同步控制

这种方法需要在需要修改ArrayList的地方使用synchronized块或锁来确保线程安全。这是一种更精细的控制方法，适用于需要更多控制和协同操作的场景。

   List<String> list = new ArrayList<>();

   // 在需要修改list的地方加锁
   synchronized (list) {
       list.add("item");
   }

这种方式要求手动管理锁，通过加锁确保在修改ArrayList时进行同步，以防止多个线程同时访问它。

3. 总结

• 一般在日常编码中，直接使用 CopyOnWriteArrayList 就能满足很多场景； 但是由于每次进行写操作时，都需要复制整个列表，这会导致写操作的性能较低，尤其在列表很大时。因此，CopyOnWriteArrayList 适用于读操作频繁、写操作较少的场景。
• 使用 CopyOnWriteArrayList 时候，应该避免在迭代过程中修改列表； CopyOnWriteArrayList 的迭代器具有弱一致性，在迭代过程中，迭代器可能无法反映出最新的修改，可能会遗漏或重复元素。如果非要强一致性，那就需要全局锁或分布式锁来处理了。
• 大多数场景中，更多的还是读多写少； 所以一般解决并发的方法，其实就是让并发写的操作，变成串行的；如果非要保证最终的强一致性，那肯定最终还是串行化处理，非常影响性能。
• 如果是分布式系统的话，那肯定就要使用分布式锁来处理了。