并发容器(二)—线程安全的List

                                                                    不积跬步，无以至千里；

                                                                                      不积小流，无以成江海。

                                                                                                              ——荀子

关于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环境中运行这段代码，多次验证，会出现两种结果：

第一种：抛出数组越界异常

java.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在插入的过程中会创建新的数组，这样在数据量特别大的情况下，对内存的消耗是很大的。当然，如果是读取操作远远大于插入时，第二种方式肯定更占优势，毕竟读取操作完全不需要加锁。