【ArrayList是线程安全的吗？】

ArrayList是线程安全的么?

ArrayList是线程不安全的，要使用线程安全的就使用Vector

操作演示

    private static List<Integer> list  = new ArrayList<>();

    private static void testList() throws InterruptedException {
        Runnable runnable = () -> {
            for (int i = 0; i < 10000; i++) {
                list.add(i);
            }
        };

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        Thread t3 = new Thread(runnable);

        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();

        System.out.println(list.size());
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            testList();
            list.clear();
        }
    }

这是它的输出结果，我们期望的结果应该都是:30000，然后并不是，这就是传说中的多线程并发问题了。

Exception in thread "Thread-2" Exception in thread "Thread-1" java.lang.ArrayIndexOutOfBoundsException: 73
	at java.util.ArrayList.add(ArrayList.java:463)
	at com.fuli.admin.utils.ComUtils.lambda$testList$0(ComUtils.java:146)
	at java.lang.Thread.run(Thread.java:748)
java.lang.ArrayIndexOutOfBoundsException: 10
	at java.util.ArrayList.add(ArrayList.java:463)
	at com.fuli.admin.utils.ComUtils.lambda$testList$0(ComUtils.java:146)
	at java.lang.Thread.run(Thread.java:748)
10003
12831
13670
11095
11598
11668
14258
11083
17317
13833

现象分析

发生ArraylndexOutOfBoundsException异常

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

定位到异常所在源代码，毫无疑问，问题是出现在多线程并发访问下，由于没有同步锁的保护，造成了ArrayList扩容不一致的问题。

程序正常运行，输出了少于实际容量的大小

这个也是多线程并发赋值时，对同一个数组索引位置进行了赋值，所以出现少于预期大小的情况。

程序正常运行，输出了预期容量的大小;

这是正常运行结果，未发生多线程安全问题，但这是不确定性的，不是每次都会达到正常预期的。

常用的线程安全的List集合有哪些?

• Vector
• SynchronizedList
• CopyOnWriteArrayList

SynchronizedList

它能把所有List接口的实现类转换成线程安全的List，比 Vector有更好的扩展性和兼容性，SynchronizedList的构造方法如下:

    protected SynchronizedList(List list) {
        super(list);
    }

    protected SynchronizedList(List list, Object lock) {
        super(list, lock);
    }

部分方法源码如下:

    public void add(int index, Object object) {
        synchronized(this.lock) {
            this.getList().add(index, object);
        }
    }

    public boolean addAll(int index, Collection coll) {
        synchronized(this.lock) {
            return this.getList().addAll(index, coll);
        }
    }

    public Object get(int index) {
        synchronized(this.lock) {
            return this.getList().get(index);
        }
    }

很可惜;它所有方法都是带同步对象锁的，和Vector—样,它不是性能最优的。在读多写少的情况， SynchronizedList这种集合性能非常差，还有没有更合适的方案?

并发包里面的两个并发集合类：
java.util.concurrent.CopyOnWriteArrayList
java.util.concurrent.CopyOnWriteArraySetCopyOnWrite
集合类也就这两个 Java 1.5开始加入

什么是CopyOnWriteArrayList?

CopyOnWrite (简称:COw):即先复制再写入
就是在添加元素的时候，先把原List列表复制一份,再添加新的元素。
添加元素时,先加锁,再进行复制替换操作,最后再释放锁。获取元素没有加锁.

这样做的好处是,在高并发的情况下,读取元素时就不用加锁,写数据时才加,大大提升了读取性能.

CopyOnWriteArraySet

CopyOnWriteArraySet逻辑就更简单了，就是使用CopyOnWriteArrayList的 addlfAbsent方法来去重的，添加元素的时候判断对象是否已经存在，不存在才添加进集合。

这两种并发集合，虽然牛逼，但只适合于读多写少的情况，如果写多读少，使用这个就没意义了，因为每次写操作都要进行集合内存复制,性能开销很大，如果集合较大，很容易造成内存溢出。