概要

要测试ArrayList的线程不安全性，可以创建多个线程同时对 ArrayList 进行修改操作（如添加、删除元素），并观察是否会引发异常或数据不一致的问题

示例代码

    public static void main(String[] args) throws InterruptedException {
        List<Integer> list = new ArrayList<>(6000);
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 3000; i++) {
                list.add(i);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 3000; i++) {
                list.add(-i);
            }
        });

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

        thread1.join(); // 主线程等待子线程执行结束  主线程才继续执行
        thread2.join();

        System.out.println("数组大小:" + list.size());
    }

执行结果：

每次结果都不一样，正确的数量因该是2个线程分别添加元素数量总和

原因

在并发环境中，当多个线程同时对 ArrayList 进行操作时，它们之间的竞争可能会导致数据丢失。例如，当多个线程同时调用 add 方法时，可能会出现数据覆盖：如果多个线程同时试图在 ArrayList 中添加元素，它们可能会在同一位置进行写操作，导致之前写入的元素被覆盖。

ArrayList 的 add 操作并不是原子的。在多线程环境下，如果两个线程同时执行 add 操作，它们可能会同时访问和修改 ArrayList 的内部数据结构。这种缺乏原子性的操作会导致竞态条件和数据丢失。

解决

用 synchronized 保证安全添加元素

public synchronized static void addNum(List<Integer> list, int num) {
    list.add(num);
}

public static void main(String[] args) throws InterruptedException {
    List<Integer> list = new ArrayList<>(6000);
    
    Thread thread1 = new Thread(() -> {
        for (int i = 0; i < 3000; i++) {
            addNum(list, i);
        }
    });

    Thread thread2 = new Thread(() -> {
        for (int i = 0; i < 3000; i++) {
            addNum(list, -i);
        }
    });

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

    thread1.join();
    thread2.join();

    System.out.println("数组大小: " + list.size());
}

执行结果：

其他方法

• Collections.synchronizedList：使用 Collections.synchronizedList(new ArrayList<>()) 来包装 ArrayList，以确保对集合的操作是线程安全的。
• CopyOnWriteArrayList：使用 CopyOnWriteArrayList，这是一个线程安全的 List 实现，适用于读多写少的场景。

    public static void main(String[] args) throws InterruptedException {
        List<Integer> list = Collections.synchronizedList(new ArrayList<Integer>(6000));
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 3000; i++) {
                list.add(i);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 3000; i++) {
                list.add(-i);
            }
        });
        thread1.start();
        thread2.start();

        thread1.join(); // 主线程等待子线程执行结束  主线程才继续执行
        thread2.join();

        System.out.println("数组大小:" + list.size());
    }

总结

像 HahsMap TreeMap 都不是线程安全的，当然 HashSet 由 HashMap 实现，所以 HashSet 线程不安全; TreeSet 由 TreeMap 实现，所以 HashSet 线程不安全。为了解决这个问题，可以使用线程安全的替代品，例如通过 Collections.synchronizedSet() 来包装一个 Set，确保其线程安全。

Collections工具类中的替代品：

写时复制：
CopyOnWrite 是一种并发编程策略，常用于实现线程安全的集合类。它的核心思想是在进行写操作时，复制底层数据结构的一个副本，并在新副本上执行修改操作，旧的副本仍然保持不变，供当前正在进行的读操作使用。这种策略适用于读操作频繁、写操作较少的场景。

---

❤觉得有用的可以留个关注~~❤