多线程情况下的集合不安全

在调用多线程的情况下,使用ArrayList 进行添加操作,有可能会发生ConcurrentModificationException 异常,这个是也就是说ArrayList 并不安全,那如何进行解决,有以下3中方法
1.使用Vector.

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

2.使用Collection集合的工具类Collections工具类

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

3.最佳的解决办法就是使用CopyOnWriteArrayList

public class ListDemo {
    public static void main(String[] args) {
//        List<String> list =new ArrayList<>();//在多线程操作的情况下会不安全
        //1.解决办法,通过Collection集合的工具类
//        List<String> list = Collections.synchronizedList(new ArrayList<>());
        //2.使用CopyOnWriteArrayList 写入时复制
        /**在多个线程调用的时候,读取是固定的,然后写入是不断覆盖的
         * CopyOnWriteArrayList 可以避免覆盖,造成数据问题 ==========>>>>读写分离
         * */
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 1; i <= 100; i++) {
            new Thread(
                    ()->{
                      list.add(UUID.randomUUID().toString().substring(0,5)) ;
                        System.out.println(list);
                    },String.valueOf(i)
            ).start();
        }

    }
}

为什么使用CopyOnWriteArrayList会比以上两种方法好?这就和源码有关系,下面是CopyOnWriteArrayList的源码中add方法,这里的add方法使用的是Lock锁,可以很明显的能看出,在对集合进行写入操作时,会将原有的集合数组,进行复制,然后通过锁,保证每次的写入都是唯一性,最后再返回,保证了数据的最终一致性.

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
	//1. 使用Lock,保证写线程在同一时刻只有一个
    lock.lock();
    try {
		//2. 获取旧数组引用
        Object[] elements = getArray();
        int len = elements.length;
		//3. 创建新的数组，并将旧数组的数据复制到新数组中
        Object[] newElements = Arrays.copyOf(elements, len + 1);
		//4. 往新数组中添加新的数据	        
		newElements[len] = e;
		//5. 将旧数组引用指向新的数组
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}
————————————————
原文链接：https://blog.csdn.net/ThinkWon/article/details/102508258

下面是Vector中add的源码,Vector中的方法是通过synchronized修饰的,是独占锁,而Collections.synchronizedList的底层也是使用了synchronized关键字,在性质上来说,synchronized是一种悲观锁,如果线程没有执行完毕,不会释放锁,其他的线程只能等待,而CopyOnWriteArrayList底层是使用的Lock,ReentrantLock 实现Lock接口,ReentrantLock 表示的是可重入锁,多线程可以同步访问,相比synchorized的效率会高

    public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }