一、添加单个元素数组越界分析

add源码如下

public boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!elementData[size++] = e;return true;
}

size字段的定义

The size of the ArrayList (the number of elements it contains).

ArrayList的大小(包含元素的个数)
elementData[size++]=e
此代码分2个步骤，先执行赋值，既elementData[size]=e，然后在执行size++

模拟越界场景
定义一个数组长度为10
ArrayList list = new ArrayList(10);
假设已经添加九个元素，所以size = 9
thread 1执行add,会判断ensureCapacityInternal(size + 1)，size + 1<10,不进行扩容
thread 2执行add,会判断ensureCapacityInternal(size + 1)，size + 1<10,不进行扩容
以上thread 1和thread 2同时运行
thread 1执行elementData[size++] = e;此时size++后等于10
thread 2执行elementData[size++] = e;此时size==10, elementData[10]抛出out of index错误

  
因此验证在并行情况下，扩容临界值执行add会数组越界

二、添加集合越界分析

addList源码

public boolean addAll(Collection<? extends E> c) {Object[] a = c.toArray();int numNew = a.length;ensureCapacityInternal(size + numNew);  // Increments modCountSystem.arraycopy(a, 0, elementData, size, numNew);size += numNew;return numNew != 0;
}

数组越界原理同上，两个线程都刚好执行ensureCapacityInternal(size + numNew);且都不需要进行扩容，
在执行System.arraycopy(a, 0, elementData, size, numNew)发生越界

三、解决方案并分析

使用Collections.synchronizedList(new ArrayList<>())替代ArrayList
如果是读多写少的场景，使用CopyOnWriteArrayList替代ArrayList

collections源码分析

public static <T> List<T> synchronizedList(List<T> list) {return (list instanceof RandomAccess ?new SynchronizedRandomAccessList<>(list) :new SynchronizedList<>(list));
}

最终new 出SynchronizedRandomAccessList类

static class SynchronizedRandomAccessList<E>extends SynchronizedList<E>implements RandomAccess

SynchronizedRandomAccessList继承SynchronizedList

static class SynchronizedList<E>extends SynchronizedCollection<E>implements List<E> {

接着又继承SynchronizedCollection

static class SynchronizedCollection<E> implements Collection<E>, Serializable {private static final long serialVersionUID = 3053995032091335093L;final Collection<E> c;  // Backing Collectionfinal Object mutex;     // Object on which to synchronizeSynchronizedCollection(Collection<E> c) {this.c = Objects.requireNonNull(c);mutex = this;}SynchronizedCollection(Collection<E> c, Object mutex) {this.c = Objects.requireNonNull(c);this.mutex = Objects.requireNonNull(mutex);}public int size() {synchronized (mutex) {return c.size();}}public boolean isEmpty() {synchronized (mutex) {return c.isEmpty();}}public boolean contains(Object o) {synchronized (mutex) {return c.contains(o);}}public Object[] toArray() {synchronized (mutex) {return c.toArray();}}public <T> T[] toArray(T[] a) {synchronized (mutex) {return c.toArray(a);}}public Iterator<E> iterator() {return c.iterator(); // Must be manually synched by user!}public boolean add(E e) {synchronized (mutex) {return c.add(e);}}public boolean remove(Object o) {synchronized (mutex) {return c.remove(o);}}public boolean containsAll(Collection<?> coll) {synchronized (mutex) {return c.containsAll(coll);}}public boolean addAll(Collection<? extends E> coll) {synchronized (mutex) {return c.addAll(coll);}}public boolean removeAll(Collection<?> coll) {synchronized (mutex) {return c.removeAll(coll);}}public boolean retainAll(Collection<?> coll) {synchronized (mutex) {return c.retainAll(coll);}}public void clear() {synchronized (mutex) {c.clear();}}public String toString() {synchronized (mutex) {return c.toString();}}// Override default methods in Collection@Overridepublic void forEach(Consumer<? super E> consumer) {synchronized (mutex) {c.forEach(consumer);}}@Overridepublic boolean removeIf(Predicate<? super E> filter) {synchronized (mutex) {return c.removeIf(filter);}}@Overridepublic Spliterator<E> spliterator() {return c.spliterator(); // Must be manually synched by user!}@Overridepublic Stream<E> stream() {return c.stream(); // Must be manually synched by user!}@Overridepublic Stream<E> parallelStream() {return c.parallelStream(); // Must be manually synched by user!}private void writeObject(ObjectOutputStream s) throws IOException {synchronized (mutex) {s.defaultWriteObject();}}}

看得出，使用了final Collection<E> c存放具体集合类，
每个方法使用synchronized进行同步限制，锁对象为mutex=this,

四、总结

1.ArrayList不适合多线程场景使用
2.线程安全List有Collections.synchronizedList和CopyOnWriteArrayList
3.Collections集合类很多好用的方法，注意Collection是接口，写法上区分有没有s
4.静态内部类synchronizedList 继承-> SynchronizedRandomAccessList 继承-> SynchronizedCollection
5.除了静态内部类synchronizedList，同理有静态内部类synchronizedSet和静态内部类synchronizedMap