学习Java中的队列：Vector、ArrayList、CopyOnWriteArrayList、SynchronizedList

1、Vector

背景：Vector是在 JDK 1.0 提供的，但是事实上已经很少有人使用了。主要原因是性能差，且不符合大部分开发时的需求。但是在 JDK 中，Vector一直没有被标记为Deprecated。

实现：Vector底层是一种可增长对象数组,查询快,增删慢；几乎在所有操作方法上，都用synchronized关键字实现方法同步来保证线程安全，这种同步方式可以对单一操作进行加锁，比如多个线程同时执行add会同步阻塞执行，但是多线程执行add和remove时，就不会阻塞了。

缺点：大部分需要对队列加锁的场景，是想对整个队列加锁，而不仅仅是对单一操作加锁。所以Vector不符合大部分开发时的需求，但是又额外增加了同步操作带来的性能开销。所以现在基本都是使用其他的队列来替代Vector的使用。

而且，任何想要通过Vector同步的队列，都需要转换为Vector的数组结构。大家都知道，数组存储需要连续空间，顺序读取效率表现优秀，但是插入和删除效率就比较差了。

但是，Vector也并不是一无是处。在Vector中可以指定扩容大小，如果没有指定，默认扩容到原来的 2 倍；而ArrayList只能扩容到 1.5 倍，没有办法自定义扩容大小。（当然，这也并没有什么太大的用处）

private void grow(int var1) {
    int var2 = this.elementData.length;
    int var3 = var2 + (this.capacityIncrement > 0 ? this.capacityIncrement : var2);
    if (var3 - var1 < 0) var3 = var1;
    if (var3 - 2147483639 > 0)  var3 = hugeCapacity(var1);    
    this.elementData = Arrays.copyOf(this.elementData, var3);
}

除此之外，Vector的迭代器用synchronized (Vector.this)加锁，其实也是对当前类实例加锁，和我们自己实现的加锁方式一致。Vector能够保证在开发人员无意识的情况下，避免为同步造成的错误，这也是Vector的一个优点

public synchronized ListIterator<E> listIterator() {
 	return new Vector.ListItr(0);
}

public synchronized Iterator<E> iterator() {
    return new Vector.Itr();
}

ArrayList

背景：ArrayList是在 JDK 1.1 提供的，作为Vector的继任者（ArrayList实现方式与Vector几乎完全相同），ArrayList把方法上的synchronized全部去掉了，完全没有实现同步，是非线程安全的。

实现：ArrayList继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的；（默认初始容量大小为 10）

它的非线程安全，还体现在迭代器的快速失败上。在使用方法iterator和listIterator创建迭代器之后，如果还对原来的ArrayList队列进行修改（add 或 remove），迭代器迭代的时候就会报ConcurrentModificationException异常。源码如下：

private class Itr implements Iterator<E> {
	/* 省略代码 */
	final void checkForComodification() {
       if (modCount != expectedModCount)
           throw new ConcurrentModificationException();
    }
}

在多线程场景中，添加元素可能会丢失数据，或者发生数组越界异常

SynchronizedList

SynchronizedList是Collections的静态内部类，使用Collections.synchronizedList()静态方法创建。

它的大多数方法通过synchronized (mutex){…}代码块同步方式，因为加锁对象mutex是队列对象中定义的相同对象，所以对mutex加锁时，可以在多线程之间实现阻塞。但是这种实现方式和Vector在方法上加锁没有本质的区别，所以Vector存在的困境，SynchronizedList依然存在

那么问什么还会有SynchronizedList存在呢？

SynchronizedList定位是包装类，可以包装所有List的子类。无论是ArrayList还是LinkedList都能过实现同步，完全不会修改底层数据结构，既实现同步，又保留底层接口的优点。比如LinkedList的插入、删除效率，ArrayList的顺序读取。而且，一个包装类就解决所有List子类的同步需求，完全不需要重复实现一遍。

相比较Vector，任何想要同步的队列，都需要转换为Vector的数组结构。

---

SynchronizedList中的iterator和listIterator方法都没有实现同步，所以在获取迭代器的时候不会阻塞。
想要使用迭代器，需要用户手动实现同步

public Iterator<E> iterator() {
    return c.iterator(); // Must be manually synched by user!
}
public ListIterator<E> listIterator() {
    return list.listIterator(); // Must be manually synched by user
}

注意：在使用SynchronizedList时，官方推荐在获取到SynchronizedList之后，再使用synchronized进行一层修饰

List list = Collections.synchronizedList(new ArrayList());
      ...
synchronized (list) {
    Iterator i = list.iterator(); // Must be in synchronized block
    while (i.hasNext())
        foo(i.next());
}

CopyOnWriteArrayList

CopyOnWriteArrayList是从 JDK 1.5 开始提供的，是concurrent并发包下的一个类

public boolean add(E e) {
   final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

由add方法可以看出，CopyOnWriteArrayList借助ReentrantLock实现同步；在synchronized优化之前（jdk1.6之前没有锁升级机制），ReentrantLock性能高于synchronized。

CopyOnWriteArrayList也是通过数组实现的，但是在数组前面增加了volatile关键字，实现了多线程情况下数组的可见性；
CopyOnWriteArrayList在add添加元素的时候，实现方式是重建数组对象，替换原来的数组引用。与ArrayList的扩容方式相比，减少了空间，但是也增加了赋值数组的性能开销。在get获取元素的时候，没有任何锁，直接数据返回。

CopyOnWriteArrayList的迭代器时通过COWIterator实现的，调用iterator方法时，将当前队列中数组的快照赋值到迭代器中的数组引用上。如果原来的队列发生修改，队列中数组会指向别的引用，而迭代器中的数组不会发生变化，所以在多线程执行过程中，通过迭代器遍历数组，也可以修改队列中的数据。这种方式保障线程安全的同时，也可能会出现数据不一致的情况。

static final class COWIterator<E> implements ListIterator<E> {
private final Object[] snapshot;
   /** Index of element to be returned by subsequent call to next.  */
   private int cursor;

   private COWIterator(Object[] elements, int initialCursor) {
       cursor = initialCursor;
       snapshot = elements;
   }
}

总结

1、Vector只是在迭代器遍历性能很差，如果不考虑全局锁定队列，单纯读操作和单独写操作性能与SynchronizedList相差不大。
2、ArrayList完全没有同步操作，是非线程安全的；根据下标访问以及遍历效率较高，删除插入效率较低；每次扩容现有容量的50%
3、synchronized关键字没有锁升级机制之前性能比较差，可以看到 JDK1.5 之后实现的同步代码，很多是通过ReentrantLock实现的
4、SynchronizedList要求数据强一致，是队列全局加锁方式，读操作也会加锁
5、CopyOnWriteArrayList实现读写分离，适合场景是写少读多的场景（当然也要考虑数据的多少，如果数据过多，每次复制数组都会产生大量的内存开销）
6、多线程场景中除了需要考虑同步外，还需要考虑数据可见性，可以通过volatile关键字实现。