多线程下使用ArrayList

原创文章，转载请注明原文章地址，谢谢！

ArrayList是线程不安全的，具体的线程不安全表现在哪方面呢？在多线程下如果要使用ArrayList，会出现什么问题？有没有替代的解决方法呢？

ArrayList源码

ArrayList的add方法源码

public boolean add(E e) {
    // 判断容量是否足够，如果不够，则进行扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 添加元素
    elementData[size++] = e;
    return true;
}

在该add添加元素的方法中，涉及到的其他的方法如下

/**
 * Default initial capacity.
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * The size of the ArrayList (the number of elements it contains).
 *
 * @serial
 */
private int size;

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

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

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

ArrayList存放数据的容器是一个Object[]数组，用来保存元素，size是该数组中已经添加的元素个数。add方法主要有两步

• 先判断容器大小elementData是否满足要求，具体判断是size+1的大小是否超过elementData的大小，如果超过了就需要对数组进行扩容。
• 然后将元素添加到elementData指定位置上。

ArrayList线程不安全的场景

• 数组越界ArrayIndexOutOfBoundsException
  ArrayList在指定add操作的时候，由于是分为两步来执行，由此带来了线程不安全的隐患，在多线程同时执行add的情况下，可能引发数组越界异常，具体场景如下
  1、假设此时size大小为9。
  2、线程A开始执行add方法，此时获取到size为9，接着判断容量是否满足需求。
  3、线程B此时也执行add方法，获取到的size也是9，也开始判断容量是否满足需求。
  4、如果需求大小为10，此时线程A判断，发现不需要扩容。
  5、此时线程B经过判断，也是发现不需要扩容的。
  6、接着线程A开始执行添加元素， elementData[size++] = e完成后，此时size变为10。
  7、此时线程B也开始执行添加元素，elementData[size++] = elementData[10] = e，因为数组没有经过扩容，数组的容量为10，即数组下标最大为9，那么此时线程B在添加元素的时候，便会报错。

• 元素值被覆盖或为空
  elementData[size++] = e添加元素的操作，其本身就是分为两步，并非原子操作，所以可能会带来异常。

elementData[size] = e;
size = size + 1;

这两行代码，在多线程的情况下，可能就会出现一个线程添加的元素会覆盖另一个线程已经添加的元素，具体场景如下
1、假设此时size大小为0。
2、线程A开始添加元素，值为1，执行elementData[size] = e，此时数组下标为0的位置上，值为1。
3、线程B也开始添加一个元素，执行elementData[size] = e，此时size还没有被修改，还是0，所以线程B也在数组下标为0的位置上添加元素2。
4、线程A执行size = size + 1，此时size为1。
5、线程B执行size = size + 1，此时size为2。
6、线程A和线程B执行结束之后，此时size为2，数组下标为0的位置上是2，因为线程B将线程A添加的元素覆盖了，而下标1的位置上为空。如果此时再有线程C添加元素，不会添加到位置1上，因为此时size已经为2，线程C添加元素，只会添加到位置2上，所以位置1上一直为空。

代码演示

public class Test {
    public static void main(String[] args) throws Exception {
        final List<Integer> list = new ArrayList<>();
        // 线程A添加0-99整数
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                list.add(i);
                try {
                    Thread.sleep(1);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "线程A").start();

        // 线程B添加100-199整数
        new Thread(() -> {
            for (int i = 100; i < 200; i++) {
                list.add(i);
                try {
                    Thread.sleep(1);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "线程B").start();
        Thread.sleep(1000);
        for (int i = 0; i < list.size(); i++) {
            System.out.println("第" + (i + 1) + "个元素为：" + list.get(i));
        }
    }
}

运行结果如下，出现上述两种线程不安全的问题

Exception in thread "线程B" java.lang.ArrayIndexOutOfBoundsException: 49
    at java.util.ArrayList.add(ArrayList.java:463)
    at com.example.demo.test.Test.lambda$main$1(Test.java:34)
    at java.lang.Thread.run(Thread.java:748)
第1个元素为：0
第2个元素为：100
第3个元素为：1
......
第49个元素为：24
第50个元素为：null
......

多线程下如何处理ArrayList

• Collections.synchronizedList

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

• Vector，其add方法加了synchronized

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

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

• CopyOnWriteArrayList

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

博客内容仅供自已学习以及学习过程的记录，如有侵权，请联系我删除，谢谢！