ArrayList/Vector的原理、线程安全和迭代Fail-Fast

疑问

* ArrayList是非线程非安全的，具体是指什么？具体会产生什么问题？
* ArrayList的内部原理是什么？为什么可以动态扩容？
* Vector是线程安全的，具体是如何实现的？为什么不再推荐使用？还有它的适用场景吗？
* 迭代时集合发生了修改怎么办？什么是fail-fast？

线程安全和非线程安全

Vector内部是如何实现线程安全的？

public class Vector
{
     Object[] elementData;       // 存放元素的数组
     int elementCount;           // 存放元素的实际数量，默认的容量（capacity）是10
     int capacityIncrement;      // 当容量占满时，扩容量，如果未指定，则原先的2倍（doubled）

     // 构造函数
     public Vector(int initialCapacity/* 初始容量 */,int capacityIncrement/*扩容量*/){}
}

其 capacity()/size()/isEmpty()/indexOf()/lastIndexOf()/removeElement()/addElement() 等方法均是 sychronized 的，所以，对Vector的操作均是线程安全的。

Vector是线程安全的，有问题吗？

如果用户知道自己是在单线程情况下运行，那么Vector本身的线程安全就没有必要了，耗费性能。JDK至少要提供一种非线程安全的List，供用户在不同的场景中选择，由此ArrayList出现了。ArrayList虽然是非线程安全的，但如果你想使用线程安全的ArrayList，可以在ArrayList的基础上，通过同步块来实现，或者使用同步包装器（Collections.synchronizedList），还可以使用J.U.C中的CopyOnWriteArrayList。但对于Vector，在其基础之上没有办法获得非线程安全的Vector（无法解耦）。这说明，在设计Vector时，没有做好分离性（数据结构功能和同步功能的分离）。

ArrayList的非线程安全会有什么问题？

Demo

final ArrayList<String> list = new ArrayList<String>(); // 多线程共享的ArrayList
for(int i=0;i<100;i++) // 多个线程同时进行写操作
{
     new Thread(new Runnable(){
        @Override
        public void run() {
        for(int j=0;j<1000;j++)
        {
             list.add("hello"); // 多线程下，此处引发ArrayIndexOutOfBoundsException
       }
    }}).start();
}

ArrayList的内部原理

public class ArrayList<E>
{
    private Object[] elementData;      // 存储元素的数组。其分配的空间长度是capacity。
    private int size;                  // elementData存储了多少个元素。

    public ArrayList(){this(10);};     // 默认capacity是10

    boolean add(E e)
    {
         ensureCapacityInternal(size + 1);  // capacity至少为 size+1
         elementsData[size++]=e;            // size++
         return true;
    }
    void ensureCapacityInternal(int minCapacity){
         if(minCapacity > elementData.length)     // 扩容
              grow(minCapacity);
    }
    void grow(int minCapacity){
         int oldCapacity = elementData.length;
         int newCapacity = oldCapacity + (oldCapacity >> 1);     // 约是原先的1.5倍。
         elementData = Arrays.copyOf(elementData,newCapacity );
    }
}

如何实现线程安全的ArrayList？

#1:自己手动同步
public static List<E> list = ... ;
lock.lock();
list.add();
lock.unlock();

#2:使用同步包装器
List<E> syncList = Collections.synchronizedList(new ArrayList<E>());
迭代时，需要包含在同步块当中
synchronized(syncList){
    while(Iterator<E> iter = syncList.iterator();iter.hasNext();){}
}

#3:使用J.U.C中的CopyOnWriteArrayList。

迭代 / Fail-fast

什么是fail-fast？

一个fail-fast的系统是指当发现任何可能导致过程失败的情况时，立刻抛出错误。一个fail-fast的迭代器是指当迭代的集合正在迭代时检测到集合发生了修改，就立刻抛出一个异常。

ArrayList的fail-falst的实现

public class ArrayList
{
     protected transient int modCount = 0; // 用来记录修改次数（继承自AbstractList）

     add() / remove() / trimToSize() / ensureCapacity() ...
     {
          modCount++; // 每次修改，modCount均自增
     }

     class Itr implements Iterator<E>
     {
          int expectedModCount = modCount;     // 记录modeCount当前值(一次快照)

          public E next() {
               checkForComodification();       // next()操作之前，check一次
               ...
          }

          public void remove(){
               checkForComodification();       // remove()操作之前，check一次
               ...
               ArrayList.this.remove(lastRet);
               ...
　　　　　　　　 // 更新modCount的快照
　　　　　　　　 // 这说明通过iter的Remove()来删除元素不会抛出ConcurrentModificationException
               expectedModCount = modCount;
          }

          final void checkForComodification() {
               if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
          }
     }
}

迭代时如何修改ArrayList？

Iterator<String> iter = list.iterator();
int j=0;
while(iter.hasNext())
{
    System.out.println(iter.next());
    if(j==3)
    {
         list.remove(0);  // 出现 ConcurrentModificationException。
         iter.remove();   // （单线程下）不会引发ConcurrentModificationException。但迭代器也只有这个修改相关的操作。
    }
    j++;
}

ConcurrentModificationException 这个异常看起来像是“多线程并发修改异常”，其实单线程下的迭代时修改也可能会出现这个异常。单线程下，迭代时通过集合自身的操作修改集合，会引发异常；通过迭代器修改（即 iter.remove() ）不会引发 ConcurrentModificationException 。多线程下，迭代时通过迭代器修改可能会引发 ConcurrentModificationException ，此时应该使用线程安全的集合。