java.util.concurrent.CompletionException: java.lang.ArrayIndexOutOfBoundsException异常的原因分析及解决方

        生产环境抛出的ArrayIndexOutOfBoundsException异常，涉及到容器在多线程情况下添加元素问题。

1.错误日志

java.util.concurrent.CompletionException: java.lang.ArrayIndexOutOfBoundsException
  at java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:273)
  at java.util.concurrent.CompletableFuture.completeThrowable(CompletableFuture.java:280)
  at java.util.concurrent.CompletableFuture$AsyncRun.run(CompletableFuture.java:1629)
  at java.util.concurrent.CompletableFuture$AsyncRun.exec(CompletableFuture.java:1618)
  at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
  at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1056)
  at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1692)
  at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:157)
​
​
Caused by: java.lang.ArrayIndexOutOfBoundsException
  at java.util.ArrayList.addAll(ArrayList.java:580)
  at com.service.Service.lambda$null$458(AgeService.java:412)
  at java.util.concurrent.CompletableFuture$AsyncRun.run(CompletableFuture.java:1626)
  ... 5 more

2.问题代码

int len = components.size();
List<CompletableFuture> futureList = new ArrayList<>(len);
List<Vo> vos = new ArrayList();
components.stream()
        .filter(Objects::nonNull)
        .forEach(component -> {
            futureList.add(CompletableFuture.runAsync(() -> {
                ComponentType componentType = ComponentType.fromValue(component.getType());
                if (componentType != null) {
                    switch (componentType) {
                        case SLIDE:
                            vos.addAll(this.getSlides(component));
                            break;
                        case NAV:
                            vos.addAll(this.getNavs(component));
                            break;
                        case MODULE:
                            vos.addAll(this.getModules(component, uid, corpId));
                            break;
                        default:
                            break;
                    }
                }
            }));
        });
​
if (!CollectionUtils.isEmpty(futureList)) {
    CompletableFuture.allOf(futureList.toArray(new CompletableFuture[0])).join();
}

3.原因分析

可以看到是在多线程中的ArrayList的addAll() 操作抛异常，出现了数组溢出，造成这个异常的原因是ArrayList在添加资源时是非原子性的。操作源码如下：

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}
​
 public void add(int index, E element) {
        rangeCheckForAdd(index);
​
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

现在我们假如有两个线程在对list插入值，这时线程A获取到的size大小为9，线程B获取的size大小也为9，但是线程A在执行完ensureCapacityInternal(size + 1)后时间片用完了，线程B得以执行，这时线程B发现size+1=10，刚好满足容量大小，不需要进行扩容，这时线程A得到时间片，这时它来执行 elementData[size++] = e时，然而现在size大小为10，这时进行插入就会出现数组越界情况。另外，我们发现size字段没有使用volatile修饰，size++本身就是非原子性的，多个线程之间访问冲突，这时两个线程可能对同一个位置赋值，就可能出现size小于期望值的结果。

4.解决方案

将ArrayList替换为Collections.synchronizedList(List<T> list)或者CopyOnWriteArrayList(List<T> list)。

​
Collections.synchronizedList(List<T> list)：
    @Override
    public boolean addAll(Collection<? extends T> c) {
        synchronized(mutex) {
            return backingList.addAll(c);
        }
    }
​
​
CopyOnWriteArrayList(List<T> list)：
  
        /** The array, accessed only via getArray/setArray. */
        private transient volatile Object[] array;
​
       public boolean addAll(Collection<? extends E> c) {
        Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?
            ((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();
        if (cs.length == 0)
            return false;
        //获取重入锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (len == 0 && cs.getClass() == Object[].class)
                setArray(cs);
            else {
                Object[] newElements = Arrays.copyOf(elements, len + cs.length);
                System.arraycopy(cs, 0, newElements, len, cs.length);
                setArray(newElements);
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

（1）Collections.synchronizedList(List<T> list)

无论是读取还是写入，它都会进行加锁，当我们并发级别特别高，线程之间在任何操作上都会进行等待

（2）CopyOnWriteArrayList(List<T> list)

从源码中，我们可以看出add操作中使用了重入锁，但是此锁只针对写-写操作。为什么读写之间不用互斥，关键就在于添加值的操作并不是直接在原有数组中完成，而是使用原有数组复制一个新的数组，然后将值插入到新的数组中，最后使用新数组替换旧数组，这样插入就完成了。大家可以发现，使用这种方式，在add的过程中旧数组没有得到修改，因此写入操作不影响读取操，另外，数组定义private transient volatile Object[] array，其中采用volatile修饰，保证内存可见性，读取线程可以马上知道这个修改。

5.总结

在JDK中，获取线程安全的List，我们可以使用Collections.synchronizedList(List<T> list)方式，也可以使用CopyOnWriteArrayList类。在真实环境中，使用它们可以根据我们的业务需要，在插入操作远远超过读取时，建议使用第一种方式，这是因为CopyOnWriteArrayList在插入的过程中会创建新的数组，这样在数据量特别大的情况下，对内存的消耗是很大的。当然，如果是读取操作远远大于插入时，第二种方式肯定更占优势，毕竟读取操作完全不需要加锁。