本文转载自https://blog.csdn.net/p_programmer/article/details/86027076
关于ArrayList，我们都知道它是线程非安全的容器，在并发环境中使用它，可能会出现无法挽回的错误。
并发下的ArrayList
那么它究竟会出现什么问题呢？我们写一段简单的代码看一下：
public class ArrayListDemo {
static ArrayList<Integer> list=new ArrayList<>();
public static void main(String[] args) throws InterruptedException {
Runnable runnable = () -> {
for (int i = 0; i < 10000; i++) {
list.add(i);
}
};
Thread one = new Thread(runnable);
Thread two = new Thread(runnable);
one.start();
two.start();
one.join();
two.join();
System.out.println(list.size());
}
}
这段代码中，我们创建了两个线程，同时对ArrayList添加10000个元素，如果我们运行这段代码，我们肯定期望它返回的是20000。可是我在JDK1.8环境中运行这段代码，多次验证，会出现两种结果：
第一种：抛出数组越界异常
ava.lang.ArrayIndexOutOfBoundsException: 163
at java.util.ArrayList.add(ArrayList.java:459)
at com.release.util.container.ArrayListDemo.lambda$main$0(ArrayListDemo.java:15)
at java.lang.Thread.run(Thread.java:748)
第二种：结果<20000
这是为什么呢？我们来看看ArrayList的部分源码：
//存放list集合元素的数组,默认容量10
transient Object[] elementData;
//list大小
private int size;
我们再来看看add源码:
public boolean add(E e) {
//确定添加元素之后，集合的大小是否足够，若不够则会进行扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//插入元素
elementData[size++] = e;
return true;
}
现在我们假如有两个线程在对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小于期望值的结果。
synchronizedList()&CopyOnWriteArrayList
在实际项目中，List是我们使用非常频繁的容器，那么如果在并发环境中，我们怎么获取到线程安全的List容器呢？看过前一篇博客《并发容器(一)—线程安全的Map》的朋友，相信大家都知道Collections这样的一个类，使用它我们可以获取线程安全的List容器—Collections.synchronizedList(List<T> list)，但是无论是读取还是写入，它都会进行加锁，当我们并发级别特别高，线程之间在任何操作上都会进行等待，因此在某些场景中它不是最好的选择。在很多的场景中，我们的读取操作可能远远大于写入操作，这时使用这种方式，显然不能让我们满意，那么怎么办呢？别担心，JDK已经为我们考虑好了，为了将读取的性能发挥到极致，提供了CopyOnWriteArrayList类，该类在使用过程中，读读之间不互斥并且更厉害的是读写也不互斥。下面，我们来看看它如何做到的：
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();
}
}
从源码中，我们可以看出add操作中使用了重入锁，但是此锁只针对写-写操作。为什么读写之间不用互斥，关键就在于添加值的操作并不是直接在原有数组中完成，而是使用原有数组复制一个新的数组，然后将值插入到新的数组中，最后使用新数组替换旧数组，这样插入就完成了。大家可以发现，使用这种方式，在add的过程中旧数组没有得到修改，因此写入操作不影响读取操，另外，数组定义private transient volatile Object[] array，其中采用volatile修饰，保证内存可见性，读取线程可以马上知道这个修改。下面我们来看看读取的操作：
public E get(int index) {
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}
final Object[] getArray() {
return array;
}
读取操作完全没有使用任何的同步控制或者是加锁，这是因为array数组内部结构不会发生任何改变，只会被另外一个array所替换，因此读取是线程安全的。
大家可以使用上面描述的两种方式，来测试结果是否和我们预期的一样。另外关于这两种方式，大家可以测一测它们在读多写少和写多读少情况下的性能有何不同。
总结
在JDK中，获取线程安全的List，我们可以使用Collections.synchronizedList(List<T> list)方式，也可以使用CopyOnWriteArrayList类。在真实环境中，使用它们可以根据我们的业务需要，在插入操作远远超过读取时，建议使用第一种方式，这是因为CopyOnWriteArrayList在插入的过程中会创建新的数组，这样在数据量特别大的情况下，对内存的消耗是很大的。当然，如果是读取操作远远大于插入时，第二种方式肯定更占优势，毕竟读取操作完全不需要加锁。
