集合不安全之 ArrayList及其三种解决方案【CopyOnWriteArrayList 、synchronizedList、Vector 】-CFANZ编程社区

文章目录

一、前言

我们在高并发的场景下，难免会出现并发问题，特别是ArrayList这种常用的集合。这种事情还是要考虑的，今天就带大家一起看一下ArrayList为什么不安全？有哪些解决方案呢？

二、为什么线程不安全

1. 出错演示

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

public class ArrayListDemo {

    public static void main(String[] args) {

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

        for (int x = 0; x < 20; x++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            },String.valueOf(x)).start();
        }
    }
}

2. ConcurrentModificationException（并发修改异常）

在这里插入图片描述
3. 原因

ArrayList 是线程不安全的，多个线程同时操作会出异常，并发修改出现异常，导致modCount和操作次数不一致。

//ArrayList源码
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

三、解决方案一CopyOnWriteArrayList （推荐，读多写少场景）

1. 解决方案

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;

public class ArrayListDemo {

    public static void main(String[] args) {

        List<String> list = new CopyOnWriteArrayList();
        for (int x = 0; x < 20; x++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            },String.valueOf(x)).start();
        }
    }
}

2. 源码解读

/** 
 * 写时复制
 * 思想就是先拷贝出来，在拷贝集合的最后添加新元素，最后把集合在set进去
 * 写的时候进行加锁，读没有限制
 * 适用场景：读多写少
 */
public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    // 加可重入锁
    lock.lock();
    try {
        // 拷贝当前集合数组
        Object[] elements = getArray();
        // 获取当前集合数组长度
        int len = elements.length;
        // 原集合数组空间+1，同时将原集合数组复制
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        // 把新增元素赋值到新集合数组中
        newElements[len] = e;
        // 最后再把新集合数组设置到集合中
        setArray(newElements);
        return true;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

四、Collections.synchronizedList（加锁）

1. 解决方案

public class ArrayListDemo {

    public static void main(String[] args) {

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

        for (int x = 0; x < 20; x++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            },String.valueOf(x)).start();
        }
    }
}

2. 源码解读（加锁同步代码块）

public boolean add(E e) {
    synchronized (mutex) {return c.add(e);}
}

五、Vector （加锁）

1. 解决方案

public class ArrayListDemo {

    public static void main(String[] args) {

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

        for (int x = 0; x < 20; x++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            },String.valueOf(x)).start();
        }
    }
}

2. 源码解读（加锁同步方法）

public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}