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

                                                                    不积跬步,无以至千里;

                                                                                      不积小流,无以成江海。

                                                                                                              ——荀子

关于ArrayList,我们都知道它是线程非安全的容器,在并发环境中使用它,可能会出现无法挽回的错误。

并发下的ArrayList

那么它究竟会出现什么问题呢?我们写一段简单的代码看一下:

public class ArrayListDemo {
    static ArrayList 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 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 list)方式,也可以使用CopyOnWriteArrayList类。在真实环境中,使用它们可以根据我们的业务需要,在插入操作远远超过读取时,建议使用第一种方式,这是因为CopyOnWriteArrayList在插入的过程中会创建新的数组,这样在数据量特别大的情况下,对内存的消耗是很大的。当然,如果是读取操作远远大于插入时,第二种方式肯定更占优势,毕竟读取操作完全不需要加锁。

你可能感兴趣的:(多线程笔记)