jdk version：1.8

成员变量

protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;

capacityIncrement 为每次扩容时自定义增加的容量值

构造方法

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    //capacityIncrement 为每次扩容时自定义增加的容量值
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}
public Vector() {
    //默认容量大小为 10 
    this(10);
}
public Vector(Collection<? extends E> c) {
    elementData = c.toArray();
    elementCount = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}

add

public synchronized boolean add(E e) {
    //加了 synchronized 锁，是线程安全的。
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}
private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private void grow(int minCapacity) {
    // overflow-conscious code
    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);
}
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

没啥好说的，和 ArrayList 类似，只不过每次最小扩容量可以自定义，如果没有自定义，就是每次都最小扩容翻倍。

get、set、remove

public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    return elementData(index);
}

public synchronized E set(int index, E element) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

 public synchronized E remove(int index) {
     modCount++;
     if (index >= elementCount)
         throw new ArrayIndexOutOfBoundsException(index);
     E oldValue = elementData(index);
     int numMoved = elementCount - index - 1;
     if (numMoved > 0)
         System.arraycopy(elementData, index+1, elementData, index,
                          numMoved);
     elementData[--elementCount] = null; // Let gc do its work
     return oldValue;
 }

以上三个操作方法都没啥说的，代码一目了然，和 ArrayList 相比，每个方法都加了 synchronized，是线程安全的。

Stack

stack 先进后出。继承与 Vector，所以是线程安全的。本身代码不多。

class Stack<E> extends Vector<E> {
    public Stack() {
    }
    public E push(E item) {
        //添加元素
        addElement(item);
        return item;
    }
    public synchronized E pop() {
        E       obj;
        int     len = size();
        obj = peek();
        removeElementAt(len - 1);
        return obj;
    }
    public synchronized E peek() {
        int     len = size();
        if (len == 0)
            throw new EmptyStackException();
        //获取最后一个元素
        return elementAt(len - 1);
    }
    public boolean empty() {
        return size() == 0;
    }
    public synchronized int search(Object o) {
        int i = lastIndexOf(o);
        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }
    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = 1224463164541339165L;
}

addElement

也是线程安全的

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

size

也是线程安全的

public synchronized int size() {
    return elementCount;
}

elementAt

也是线程安全的

public synchronized E elementAt(int index) {
    if (index >= elementCount) {
        throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
    }
    return elementData(index);
}

总结

所以 stack 的 push、pop、peek、empty、search 都是线程安全的。
stack 的先进后出是，往末尾添加元素，再从末尾取出元素。