学会了CopyOnWriteArrayList可以再多和面试官对线三分钟-轻识

在这之前的几篇文章：

学习并发先看这一介绍篇
五分钟带你入门线程
Thread类和Runnable接口的源码剖析
这一篇我们来了解Synchronized、Volatile、Final关键字
一篇搞懂Synchronized底层实现
学习volatile这一篇就够了
阿里这样的公司，为什么总是用final关键字来考验求职者
八仙过海，四种同步（感谢你，苏小落）
深入线程池的问题连环炮
学Java的竟然有人不会AQS机制
从ReentrantLock的角度思考AQS

ArrayList是大家用的再熟悉不过的集合了，而此集合设计之初也是为了高效率，并未考虑多线程场景下，所以也就有了多线程下的CopyOnWriteArrayList这一集合

回忆下ArrayList

集合的fail-fast机制和fail-safe机制：

fail-fast快速失败机制，一个线程A在用迭代器遍历集合时，另个线程B这时对集合修改会导致A快速失败，抛出ConcurrentModificationException 异常。在java.util中的集合类都是快速失败的

fail-safe安全失败机制，遍历时不在原集合上，而是先复制一个集合，在拷贝的集合上进行遍历。在java.util.concurrent包下的容器类是安全失败的，建议在并发环境下使用这个包下的集合类

ArrayList定义：

public class ArrayList<E> extends AbstractList<E>  implements List<E>, RandomAccess, Cloneable, java.io.Serializable  { }

ArrayList简介：

ArrayList是实现List接口的可变数组，并允许null在内的重复元素

底层数组实现，扩容时将老数组元素拷贝到新数组中，每次扩容是其容量的1.5倍，操作代价高

采用了Fail-Fast机制，面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险

ArrayList是线程不安全的，所以在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList

重点关注问题：

ArrayList默认大小(为什么是这个？)，扩容机制？

ArrayList的默认初始化大小是10（在新建的时候还是空，只有当放入第一个元素的时候才会变成10），若知道ArrayList的大致容量，可以在初始化的时候指定大小，可以在适当程度减少扩容的性能消耗（看下一个问题解析）。

至于为何是10

据说是因为sun的程序员对一系列广泛使用的程序代码进行了调研，结果就是10这个长度的数组是最常用的最有效率的。也有说就是随便起的一个数字，8个12个都没什么区别，只是因为10这个数组比较的圆满而已。

ArrayList的扩容机制

当添加元素的时候数组是空的，则直接给一个10长度的数组。当需要长度的数组大于现在长度的数组的时候，通过新=旧+旧>>1(即新=1.5倍的旧)来扩容，当扩容的大小还是不够需要的长度的时候，则将数组大小直接置为需要的长度（这一点切记！）。

ArrayList特点访问速度块，为什么？插入删除一定慢吗？适合做队列吗？

ArrayList从结构上来看属于数组，也就是内存中的一块连续空间，当我们get(index)时，可以直接根据数组的首地址和偏移量计算出我们想要元素的位置，我们可以直接访问该地址的元素，所以查询速度是O(1)级别的。

我们平时会说ArrayList插入删除这种操作慢，查询速度快，其实也不是绝对的。

当数组很大时，插入删除的位置决定速度的快慢，假设数组当前大小是一千万，我们在数组的index为0的位置插入或者删除一个元素，需要移动后面所有的元素，消耗是很大的。但是如果在数组末端index操作，这样只会移动少量元素，速度还是挺快的（插入时如果在加上数组扩容，会更消耗内存）。

个人觉得不太适合做队列，基于上面的分析，队列会涉及到大量的增加和删除（也就是移位操作），在ArrayList中效率还是不高。

ArrayList 底层实现就是数组，访问速度本身就很快，为何还要实现 RandomAccess ？

RandomAccess是一个空的接口, 空接口一般只是作为一个标识, 如Serializable接口.。

JDK文档说明RandomAccess是一个标记接口(Marker interface), 被用于List接口的实现类, 表明这个实现类支持快速随机访问功能(如ArrayList). 当程序在遍历这中List的实现类时, 可以根据这个标识来选择更高效的遍历方式。

优缺点

上面说的查询速度快自然就是其中的优点，除此之外，还可以存储相同的元素

底层数据结构属于数组，和数组的优缺点大同小异，数组属于线性表，更适合于那种在末尾经常添加数据的场景，而对于在整个list中各个位置随机添加元素比较多的情况则不太合适

因为可能会涉及到很多元素位置的移动

ArrayList还有一个比较大的缺点就是不适应于多线程环境，这个设计之初也不是用于多线程环境的，像ArrayList、LinkedList、HashMap这种常见的都是以效率优先的，都是没有考虑线程安全的，也就自然不是线程安全的

而这，恰恰也就是本文的重点，也是面试官最爱的菜

ArrayList中的Fail-fast机制

fail-fast快速失败机制，一个线程A在用迭代器遍历集合时，此时另一个线程B如果对集合进行修改，就会导致线程A快速失败，然后线程会抛出ConcurrentModificationException异常。

在java.util中的集合类都是快速失败的，快速失败机制就是应对多线程场景的

Vector真的安全吗

如何使用安全的ArrayList，很多人的答案可能是Vector，而Vector的实现其实也很简单，我给大家看段代码

是的，道理也很简单，就是直接在每个方法加上synchronized关键字

public class CaptainTest {
    private static Vector vector = new Vector();
    public static void main(String[] args) {        while (true) {            for (int i = 0; i < 10; i++) {                vector.add(i); //往vector中添加元素            }            Thread removeThread = new Thread(new Runnable() {                @Override                public void run() {                    for (int i = 0; i < vector.size(); i++) {                        Thread.yield();                        //移除第i个数据                        vector.remove(i);                    }                }            });            Thread printThread = new Thread(new Runnable() {                @Override                public void run() {                    for (int i = 0; i < vector.size(); i++) {                        Thread.yield();                        //获取第i个数据并打印                        System.out.println(vector.get(i));                    }                }            });            removeThread.start();            printThread.start();            //避免同时产生过多线程            while (Thread.activeCount() > 20) ;        }    }
}

我们来执行上面的这段代码，这段代码会产生两种线程，一种remove移除元素，一种是get获取元素，但是都调用了size方法获取大小

执行之后会报一个越界的异常，这是为啥呢，Vector不是每个方法都加上了synchronized关键字了吗，怎么会出现这种错误

加上关键字保证其它线程不能同时调用这些方法了，也就是，不能出现两个及两个以上的线程在同时调用这些同步方法

图中报错的问题的原因是：例子中的线程连续调用了两个或者两个以上的同步方法，听起来很奇怪是吗？我来解释下

例子中的removeThread线程会首先调用size方法获取大小，接着调用remove方法移除相应位置的元素，而printThread线程也是先调用size方法获取大小，接着调用get方法获取相应位置的元素

假设vector大小是5，此时printThread线程执行到i=4的时候，进入for循环但是在执行输出之前，线程的CPU时间片到了，此时printThread则转入到就绪状态

此时removeThread线程获得CPU的执行权，然后把vector中的5个元素都删除了，此时removeThread的CPU时间片到了

而此时printThread再获取到CPU的执行权，此时执行输出中的get(4)方法就会出现越界的错误，因为此时vector中的元素已经被remove线程删除了

synchronized关键字保证的是同一时间片只有一个线程进入该方法执行，但是无法保证多个线程之间的数据同步，也就是remove线程删除vector元素之后无法通知到print线程

聪明的你应该已经理解这个场景了吧，所以，vector在多线程使用的时候也不是绝对安全的

CopyOnWriteArrayList

这个就是为了解决多线程下的ArrayList而生的，位于java.util.cocurrent包下，就是为并发而设计的

我们听名字其实也可以简单的读懂，就是写的时候会复制一份新的数据，而事实是每一次的数据改动都会伴随这一次数据的复制

设计的重点其实就是读写分离，这个思想大家再熟悉不过了吧，读的时候不会加锁，而写的时候会复制一份新数据，然后加上锁之后进行修改

老规矩，先看一段代码，我们通过debug的方式来学习下先

    public static void main(String[] args) {
        CopyOnWriteArrayList list = new CopyOnWriteArrayList();        list.add("test1");
        Thread addThread = new Thread(new Runnable() {            @Override            public void run() {                list.add("test4");                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        });
        addThread.start();
    }