源码阅读系列——基础篇（Vector 集合源码分析）

我们知道Java有一个不常用的集合类Vector。因为他使用一种非常暴力的方式实现线程安全。我们看一下他的基本实现

1、类定义

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    protected Object[] elementData; // 元素数组
    protected int elementCount;  // 元素数量
    protected int capacityIncrement;   // 元素不够的时候，递增值
    
    // 设置基本大小，和扩容递增值构造函数
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }
    
    // 复制一个集合的所有元素，并创建vector
    public Vector(Collection<? extends E> c) {
        elementData = c.toArray();
        elementCount = elementData.length;
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }
}

由此可见vector其实也是一种List，他有三个重要的成员变量和两个基本的构造函数，上面也给出解释。

2、同步机制

简单看截取的一段代码

public synchronized void copyInto(Object[] anArray) {
    System.arraycopy(elementData, 0, anArray, 0, elementCount);
}
public synchronized void trimToSize() {
    modCount++;
    int oldCapacity = elementData.length;
    if (elementCount < oldCapacity) {
        elementData = Arrays.copyOf(elementData, elementCount);
    }
}
public synchronized E elementAt(int index) {
    if (index >= elementCount) {
         throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
    }

    return elementData(index);  // 获取元素
}

是的，实现很简单，就是简单的给类加锁。

3、扩容实现

我们从增加元素开始看实现

public synchronized void addElement(E obj) {
    modCount++;
    ensureCapacityHelper(elementCount + 1); // 预估大小
    elementData[elementCount++] = obj;
}

看一下ensureCapacityHelper实现

private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity); // 如果设置了扩容递增值，就使用扩容值，否则翻倍当前容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

上面的代码其实给出了解释，如果设置了扩容递增值（默认为0，设置就表示大于0）,就把数组增加扩容递增值。否则设置为原数组长度两倍。然后再把元素拷贝到新的扩容数组里面。

4、总结

从源码阅读中，可以发现三点：
1、Vector的锁机制很暴力，读写很鲁莽的加个synchronized，在我们频繁操作的时候，效率非常低下，所以轻量级多线程场景才能使用。
2、Vector的扩容方式，每次都需要拷贝元素，所以如果场景确定的话，我们指定一个大小，可以减少扩容带来的损失。
3、Vector本身的机制还是数组，所以他读取速度快。但是删除和索引插入（注1）则较麻烦。

注1：

public synchronized void insertElementAt(E obj, int index) {
    modCount++;
    if (index > elementCount) {
        throw new ArrayIndexOutOfBoundsException(index
                                                 + " > " + elementCount);
    }
    ensureCapacityHelper(elementCount + 1);
    System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
    elementData[index] = obj;
    elementCount++;
}