多线程情况下ArrayList集合类不安全的问题及解决方式

本文探讨了在多线程环境下,集合类在未加锁情况下面临的并发修改异常问题。通过对比Vector、synchronizedList和CopyOnWriteArrayList,详细解释了CopyOnWrite容器的写时复制机制,确保读操作无需加锁,实现读写分离。

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @Auther: YongXuezhen
 * @Date: 2019/5/13 16:51
 * @Description: 多线程情况下集合类不安全的问题,add方法没有加锁
 */
public class ContainNotSafeDemo {
    public static void main(String[] args) {
        //List<String> list =new Vector<>();
        //List<String> list =Collections.synchronizedList(new ArrayList<>());
        List<String> list = new CopyOnWriteArrayList<>();
        for(int i = 1;i <= 300; i++){
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
        //java.util.ConcurrentModificationException并发修改的异常
        /**
         * 1.故障现象
         *      java.util.CurrentModificationException
         *  2.导致原因
         *      并发争抢修改导致,参考花名册写名字
         *          一个人正在写,另一个同学过来抢夺,导致数据不一致异常。并发修改异常
         *  3.解决方案
         *      (1)new Vector<>();
         *      (2)Collections.synchronizedList(new ArrayList<>());
         *      (3)new CopyOnWriteArrayList<>();
         *  4.优化建议(同样的错误不犯第2次)
         */
    }
}
/**
 * 写时复制
 * CopyOnWrite容器即写时复制的容器,忘一个容器添加元素的时候,不直接往当前容器Object[]中添加,
 * 而是先将当前容器Object[]进行copy,复制出一个新的容器Object[] newElements,然后往新的容器中
 * 添加元素,添加完元素之后,再将原容器的引用指向新容器setArray(newElements);.这样做的好处是
 * 可以对CopyOnWrite容器进行并发的读,而不需要加锁,因为当前容器不会添加任何元素,所以CopyOnWrite
 * 容器也是一种读写分离的思想,读和写不同的容器。
 *
 *     public boolean add(E e) {
 *         final ReentrantLock lock = this.lock;
 *         lock.lock();
 *         try {
 *             Object[] elements = getArray();
 *             int len = elements.length;
 *             Object[] newElements = Arrays.copyOf(elements, len + 1);
 *             newElements[len] = e;
 *             setArray(newElements);
 *             return true;
 *         } finally {
 *             lock.unlock();
 *         }
 *     }
 */

 

`ArrayList` 在多线程环境下安全,主要是因为它**没有对内部操作进行同步控制**。多个线程可以同时访问和修改 `ArrayList` 的内容,而会进行任何加锁或同步操作,从而导致以下问题: --- ### 1. **内部结构的非原子性操作** `ArrayList` 的添加(`add()`)、删除(`remove()`)等操作是原子的,它们由多个步骤组成。例如: - **add(E e)** 操作包括: 1. 检查数组容量是否足够。 2. 如果够,扩容数组(创建新数组、复制旧数据)。 3. 添加元素到数组末尾。 在多线程环境下,多个线程可能同时执行这些步骤,导致: - 多个线程同时扩容,造成数据失或数组越界。 - 数据被覆盖或插入到错误的位置。 --- ### 2. **没有使用锁机制** `ArrayList` 的方法没有使用 `synchronized` 或 `ReentrantLock` 等同步机制,因此多个线程可以同时修改集合内容,导致状态一致。 --- ### 3. **迭代时的并发修改异常** 当一个线程正在遍历 `ArrayList`(如使用 `Iterator` 或增强型 for 循环),另一个线程修改了集合结构(如增删元素),会抛出 `ConcurrentModificationException` 异常。 示例代码: ```java List<String> list = new ArrayList<>(); new Thread(() -> list.forEach(System.out::println)).start(); new Thread(() -> list.add("new element")).start(); ``` 可能抛出: ``` java.util.ConcurrentModificationException ``` --- ### 4. **扩容机制的线程安全性** `ArrayList` 内部使用动态数组实现,当容量足时会扩容。扩容操作本身涉及新建数组和复制数据,是一个相对复杂的操作。如果多个线程同时触发扩容,可能导致数据失或数组一致。 --- ### 如何保证线程安全? 要使 `ArrayList` 线程安全,可以使用以下方式之一: 1. **使用 `Collections.synchronizedList`** ```java List<String> list = Collections.synchronizedList(new ArrayList<>()); ``` 2. **使用 `CopyOnWriteArrayList`(适合读多写少)** ```java List<String> list = new CopyOnWriteArrayList<>(); ``` 3. **手动加锁(如使用 `synchronized` 或 `ReentrantLock`)** ```java List<String> list = new ArrayList<>(); // 添加元素时加锁 synchronized (list) { list.add("safe element"); } ``` --- ### 总结 `ArrayList` 安全的根本原因是其内部操作未进行同步控制,导致在多线程环境下出现数据竞争、结构一致、并发修改异常等问题。要确保线程安全,应使用线程安全集合类或手动加锁。 ---
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值