java集合之ArrayList和Vector

最新推荐文章于 2024-04-22 11:30:09 发布

humbinal

最新推荐文章于 2024-04-22 11:30:09 发布

阅读量291

点赞数

分类专栏： java 文章标签： java arraylist

本文链接：https://blog.csdn.net/u012234419/article/details/103085555

版权

java 专栏收录该内容

27 篇文章 2 订阅

订阅专栏

ArrayList

ArrayList 实现于 List、RandomAccess 接口。可以插入空数据，也支持随机访问。

ArrayList相当于动态数据，其中最重要的两个属性分别是:
elementData 数组，以及 size 大小。
在调用 add() 方法的时候：

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

首先进行扩容校验。
将插入的值放到尾部，并将 size + 1 。

如果是调用 add(index,e) 在指定位置添加的话：

    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //复制，向后移动
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

也是首先扩容校验。
接着对数据进行复制，目的是把 index 位置空出来放本次插入的数据，并将后面的数据向后移动一个位置。

其实扩容最终调用的代码:

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

也是一个数组复制的过程。

由此可见 ArrayList 的主要消耗是数组扩容以及在指定位置添加数据，在日常使用时最好是指定大小，尽量减少扩容。更要减少在指定位置插入数据的操作。

线程安全性

我们再来看一下上面的add方法

public boolean add(E e) {
    /**
     * 添加一个元素时，做了如下两步操作
     * 1.判断列表的capacity容量是否足够，是否需要扩容
     * 2.真正将元素放在列表的元素数组里面
     */
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

ensureCapacityInternal()这个方法的详细代码我们可以暂时不看，它的作用就是判断如果将当前的新元素加到列表后面，列表的elementData数组的大小是否满足，如果size + 1的这个需求长度大于了elementData这个数组的长度，那么就要对这个数组进行扩容。

由此看到add元素时，实际做了两个大的步骤：

判断elementData数组容量是否满足需求
在elementData对应位置上设置值

第一个导致线程不安全的隐患:
在多个线程进行add操作时可能会导致elementData数组越界。具体逻辑如下：

列表大小为9，即size=9
线程A开始进入add方法，这时它获取到size的值为9，调用ensureCapacityInternal方法进行容量判断。
线程B此时也进入add方法，它获取到size的值也为9，也开始调用ensureCapacityInternal方法。
线程A发现需求大小为10，而elementData的大小就为10，可以容纳。于是它不再扩容，返回。
线程B也发现需求大小为10，也可以容纳，返回。
线程A开始进行设置值操作， elementData[size++] = e 操作。此时size变为10。
线程B也开始进行设置值操作，它尝试设置elementData[10] = e，而elementData没有进行过扩容，它的下标最大为9。于是此时会报出一个数组越界的异常ArrayIndexOutOfBoundsException.

第一个导致线程不安全:
elementData[size++] = e 设置值的操作同样会导致线程不安全。从这儿可以看出，这步操作也不是一个原子操作，它由如下两步操作构成：

elementData[size] = e;
size = size + 1;

在单线程执行这两条代码时没有任何问题，但是当多线程环境下执行时，可能就会发生一个线程的值覆盖另一个线程添加的值，具体逻辑如下：

列表大小为0，即size=0
线程A开始添加一个元素，值为A。此时它执行第一条操作，将A放在了elementData下标为0的位置上。
接着线程B刚好也要开始添加一个值为B的元素，且走到了第一步操作。此时线程B获取到size的值依然为0，于是它将B也放在了elementData下标为0的位置上。
线程A开始将size的值增加为1
线程B开始将size的值增加为2
这样线程AB执行完毕后，理想中情况为size为2，elementData下标0的位置为A，下标1的位置为B。而实际情况变成了size为2，elementData下标为0的位置变成了B，下标1的位置上什么都没有。并且后续除非使用set方法修改此位置的值，否则将一直为null，因为size为2，添加元素时会从下标为2的位置上开始。

我们用如下的代码可以进行安全性的校验：

public static void main(String[] args) throws InterruptedException {
    final List<Integer> list = new ArrayList<Integer>();

    // 线程A将0-1000添加到list
    new Thread(new Runnable() {
        public void run() {
            for (int i = 0; i < 1000 ; i++) {
                list.add(i);

                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }).start();

    // 线程B将1000-2000添加到列表
    new Thread(new Runnable() {
        public void run() {
            for (int i = 1000; i < 2000 ; i++) {
                list.add(i);

                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }).start();

    Thread.sleep(1000);

    // 打印所有结果
    for (int i = 0; i < list.size(); i++) {
        System.out.println("第" + (i + 1) + "个元素为：" + list.get(i));
    }
}

最后的输出结果中，有如下的部分：

第7个元素为：3
第8个元素为：1003
第9个元素为：4
第10个元素为：1004
第11个元素为：null
第12个元素为：1005
第13个元素为：6

可以看到第11个元素的值为null，这也就是我们上面所说的情况。
多测试几次的话，数组越界的异常也可以复现出来。

序列化

由于 ArrayList 是基于动态数组实现的，所以并不是所有的空间都被使用。因此使用了 transient 修饰，可以防止被自动序列化。

transient Object[] elementData;

因此 ArrayList 自定义了序列化与反序列化：

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        //只序列化了被使用的数据
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

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

    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

当对象中自定义了 writeObject 和 readObject 方法时，JVM 会调用这两个自定义方法来实现序列化与反序列化。

从实现中可以看出 ArrayList 只序列化了被使用的数据。

Vector

Vector 也是实现于 List 接口，底层数据结构和 ArrayList 类似,也是一个动态数组存放数据。不过是在 add() 方法的时候使用 synchronized 进行同步写数据，但是开销较大，所以 Vector 是一个同步容器并不是一个并发容器。

以下是 add() 方法：

    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

以及指定位置插入数据:

    public void add(int index, E element) {
        insertElementAt(element, index);
    }
    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++;
    }

线程安全性

Vector的插入有synchronized关键字变成了同步方法，因此是线程安全的。

Collections.synchronizedList()

ArrayList是线程不安全的，Vector是线程安全的。

虽然是ArrayList是线程不安全的，但是通过Collections.synchronizedList()方法可以将线程不安全的List转成线程安全的List。但是呢，在oracle的文档里，有这么一句话：

If you need synchronization, a Vector will be slightly faster than an ArrayList synchronized with Collections.synchronizedList.

Vector比Collections.synchronizedList快一点点？那这一点点到底是快在哪里呢？我们看一下SynchronizedList的代码。

static class SynchronizedList<E>
    extends SynchronizedCollection<E>
    implements List<E> {
    private static final long serialVersionUID = -7754090372962971524L;

    final List<E> list;

    SynchronizedList(List<E> list) {
        super(list);
        this.list = list;
    }
    SynchronizedList(List<E> list, Object mutex) {
        super(list, mutex);
        this.list = list;
    }

    public boolean equals(Object o) {
        if (this == o)
            return true;
        synchronized (mutex) {return list.equals(o);}
    }
    public int hashCode() {
        synchronized (mutex) {return list.hashCode();}
    }

    public E get(int index) {
        synchronized (mutex) {return list.get(index);}
    }
    public E set(int index, E element) {
        synchronized (mutex) {return list.set(index, element);}
    }
    public void add(int index, E element) {
        synchronized (mutex) {list.add(index, element);}
    }
    public E remove(int index) {
        synchronized (mutex) {return list.remove(index);}
    }

    public int indexOf(Object o) {
        synchronized (mutex) {return list.indexOf(o);}
    }
    public int lastIndexOf(Object o) {
        synchronized (mutex) {return list.lastIndexOf(o);}
    }

    public boolean addAll(int index, Collection<? extends E> c) {
        synchronized (mutex) {return list.addAll(index, c);}
    }

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

    public ListIterator<E> listIterator(int index) {
        return list.listIterator(index); // Must be manually synched by user
    }

    public List<E> subList(int fromIndex, int toIndex) {
        synchronized (mutex) {
            return new SynchronizedList<>(list.subList(fromIndex, toIndex),
                                        mutex);
        }
    }

    @Override
    public void replaceAll(UnaryOperator<E> operator) {
        synchronized (mutex) {list.replaceAll(operator);}
    }
    @Override
    public void sort(Comparator<? super E> c) {
        synchronized (mutex) {list.sort(c);}
    }
.....
}

从代码中可以看出，SynchronizedList类使用了委托(delegation)，实质上存储还是使用了构造时传进来的list，只是将list作为底层存储，对它做了一层包装。正是因为多了一层封装，所以就会比直接操作数据的Vector慢那么一点点。

从上面的代码我们也可以看出来，SynchronizedList的同步，使用的是synchronized代码块对mutex对象加锁，这个mutex对象还能够通过构造函数传进来，也就是说我们可以指定锁定的对象。而Vector则使用了synchronized方法，同步方法的作用范围是整个方法，所以没办法对同步进行细粒度的控制。而且同步方法加锁的是this对象，没办法控制锁定的对象。这也是Vector和SynchronizedList的一个区别。

线程安全并不"安全"

有时候我们在多线程环境下使用List的需求，选择了Vector或者Collections.SynchronizedList，然后就以为可以在多线程环境下安全地操作List了。但是这种想法可能会导致代码出现不可预料的错误，因为虽然Vector(以Vector为例)实现了各个方法操作的线程安全，但是当多个方法之间进行协作时，却依然会出现race condition。

比如if(!list.contains(o)) list.add(o);，还有Collections.swap(list, i, j);，如果不在外部手工加锁的话，多线程环境下，这都会出现问题。尤其是对于List经常会使用到的迭代。看一下下面这段代码：

public static void main(String[] args) throws InterruptedException {
    Vector<Integer> vector = new Vector<>();
    // 先存放1000个值让iterator有值可以遍历
    for (int i = 0; i < 1000; i++) {
        vector.add(i);
    }

    Thread iteratorThread = new Thread(new IteratorRunnable(vector));
    iteratorThread.start();

    // 主线程休眠5秒，让iteratorThread能够充分跑起来。这段时间是不会有问题的。
    TimeUnit.SECONDS.sleep(5);

    // 该线程启动之后，会结构化修改Vector，然后就会抛出ConcurrentModificationException异常
    Thread modifyVectorThread = new Thread(new ModifyVectorRunnable(vector));
    modifyVectorThread.start();
}

/**
 *  这个Runnable会不断使用迭代器(for-each语句)遍历Vector
 */
private static class IteratorRunnable implements Runnable {

    private Vector<Integer> vector;

    public IteratorRunnable(Vector<Integer> vector) {
        this.vector = vector;
    }

    @Override
    public void run() {
        while(true) {
            for (Integer i : vector) {

            }
        }
    }
}

/**
 * 这个Runnable会不断添加新元素，也就是会结构化修改Vector
 */
private static class ModifyVectorRunnable implements Runnable {
    private Vector<Integer> vector;

    public ModifyVectorRunnable(Vector<Integer> vector) {
        this.vector = vector;
    }

    @Override
    public void run() {
        while(true) {
            vector.add(1);
        }
    }
}

IteratorRunnable用来模拟迭代Vector的线程，ModifyVectorRunnable用来模拟结构化修改Vector的线程。在main函数中，iteratorThread首先开始运行，不断迭代Vector的值。主线程休眠5s，在这5s内，iteratorThread是没有问题的。5s过后，modifyVectorThread开始运行，该线程会向Vector内添加元素，也就是结构化修改Vector。

初看这段代码可能觉得不会有问题，因为Vector是线程安全的，在多线程环境下理应正常运行。但是这个线程安全是有缺陷的，再迭代的情况下，我们需要的实际上是对整个迭代过程加锁，而不是对迭代器的hasNext、next等单独的方法加锁。这段代码会报ConcurrentModificationException异常。如下：

Exception in thread "Thread-0" java.util.ConcurrentModificationException
	at java.util.Vector$Itr.checkForComodification(Vector.java:1210)
	at java.util.Vector$Itr.next(Vector.java:1163)
	at com.humbinal.study.jinjava.Test$IteratorRunnable.run(Test.java:55)
	at java.lang.Thread.run(Thread.java:748)

上面SynchronizedList源码分析中我们已经看到了JDK默认给的注释：Must be manually synched by user，因此想要得到真正线程安全的操作，迭代操作要由用户自己加锁。

如下代码即可:

public void run() {
    while(true) {
        // 对迭代过程加锁
        synchronized (vector) {
            for (Integer i : vector) {

            }
        }
    }
}