看山聊并发：Java 中 Vector 和 SynchronizedList 的区别

爱被打了一巴掌 2021-09-25 04:58 384阅读 0赞

![Java 中 Vector 和 SynchronizedList 的区别][Java _ Vector _ SynchronizedList]

你好，我是看山。

本文还是折腾 Java 中的队列，上次比较了 [Vector、ArrayList、CopyOnWriteArrayList、SynchronizedList][Vector_ArrayList_CopyOnWriteArrayList_SynchronizedList]，当时感觉挺明白，后来想想又有些不理解的地方，所以今天在重新翻出来研究一下，我承认我钻了牛角尖了。

`Vector`虽然种种问题，但是都属于设计上的问题，为什么不在后续版本中进行优化呢？`HashMap`就优化了好几次。而`SynchronizedList`这个内部类（也就是通过`Collections.synchronizedList(new ArrayList())`创建的），也是采用了和`Vector`类似的同步方式（区别是一个在方法体、一个在方法块上，差别不大），为什么大家还是舍弃`Vector`呢？

其实，在 JDK 中，`Vector`一直没有被标记为`Deprecated`，也就是说，虽然外界传说`Vector`有各种问题，但是从 JDK 官方，从没有认为这个亲儿子没用。

所以，大家不用`Vector`的原因就剩下两种：

1.  其他队列比`Vector`更加适合，优中选优
2.  大家都说`Vector`不好用，那我也不用了【个人感觉这种概率更大】

> 因为`Vector`主要是数组结构，所以下面大部分的对比都是比较的是针对`ArrayList`的同步封装。

## 有了`Vector`为什么还要有`SynchronizedList` ##

这个问题的答案是从 StackOverflow 中找到的。

在 JDK 1.2 之前，`Collections`是独立类库，不是 JDK/JRE 中的一部分。当时`synchronized`性能特别差，很多场景不需要使用同步方式，所以，独立类库的开发者删除了同步操作，这个应该就是`ArrayList`的前身。但是，少部分场景还是需要使用同步，于是就有了`SynchronizedList`，一个可以包装所有`List`子类的包装类，这个类在几乎所有方法上都加上了`synchronized`同步，这个设计与`Vector`相似。

古人说“文人相轻”，其实在编码界也是有鄙视链的。在这里就是：虽然我的设计和你的设计类似，但是我的设计就是比你的好。不过，`Collections`确实设计更优。

## 一个`SynchronizedList`实现所有`List`的同步 ##

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

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

## 将迭代器的同步权利交给用户 ##

同步方法中`SynchronizedList`和`Vector`很类似，不过迭代器方法有了不同想法。

看源码就知道，`SynchronizedList`中的`iterator`和`listIterator`方法都没有实现同步，所以在获取迭代器的时候不会阻塞。

public Iterator<E> iterator() { 
        return list.iterator(); // Must be manually synched by user!
    }
    
    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
    }

如果需要迭代的话，直接用`synchronized`包一下队列对象就可以了，代码如下：

final List<String> list = Collections.synchronizedList(new ArrayList());
    list.add("A");
    list.add("B");
    list.add("C");
    final Iterator<String> iterator = list.iterator();
    
    synchronized (list) { 
        while (iterator.hasNext()) { 
            final String next = iterator.next();
            System.out.println(next);
        }
    }

我们再看下`Vector`迭代器实现：

/** * An optimized version of AbstractList.Itr */
    private class Itr implements Iterator<E> { 
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;
    
        public boolean hasNext() { 
            // Racy but within spec, since modifications are checked
            // within or after synchronization in next/previous
            return cursor != elementCount;
        }
    
        public E next() { 
            synchronized (Vector.this) { 
                checkForComodification();
                int i = cursor;
                if (i >= elementCount)
                    throw new NoSuchElementException();
                cursor = i + 1;
                return elementData(lastRet = i);
            }
        }
    
        public void remove() { 
            if (lastRet == -1)
                throw new IllegalStateException();
            synchronized (Vector.this) { 
                checkForComodification();
                Vector.this.remove(lastRet);
                expectedModCount = modCount;
            }
            cursor = lastRet;
            lastRet = -1;
        }
    
        // 此处省略一些方法
    }

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

## `Vector`不完全一无是处 ##

虽然`Vector`在其他地方败给了`Collections`，但是在扩容这方面，还有一个可取之处。先看看`Vector`的扩容方法：

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);
    }

在计算新数组长度的时候，会检查`capacityIncrement`是否大于 0，如果是，就扩容`capacityIncrement`的大小。就是说，在`Vector`中可以指定扩容大小，如果没有指定，默认扩容到原来的 2 倍；而`ArrayList`只能扩容到 1.5 倍，没有办法自定义扩容大小。

> 仔细想想，这点并没有什么用处。

## 文末总结 ##

1.  `Vector`内部结构是数组，与`Collections.synchronizedList(new ArrayList())`类似。
2.  `Vector`可以指定扩容大小，默认是扩容到原数组长度的 2 倍；`ArrayList`不能指定扩容大小，直接扩容到原数组大小的 1.5 倍。
3.  `SynchronizedList`是一个包装类，可以将`List`子类都包装为同步队列，从非线程安全队列转为线程安全队列，没有性能延迟，直接包装即可；`Vector`是一个基于数组的同步队列，其他队列想要转换为`Vector`，需要有数据拷贝。
4.  `SynchronizedList`的迭代器没有做同步，需要用户自己实现；`Vector`的迭代器做好了同步，开发人员不需要关心同步。
5.  `Vector`至今未标记`Deprecated`，而且随着 JDK 发布，也在更新实现。虽然 JDK 承诺兼容，但是一直没有标记过期，其用意不得而知。

## 推荐阅读 ##

1.  [认识 Java 中的队列：Vector、ArrayList、CopyOnWriteArrayList、SynchronizedList][Vector_ArrayList_CopyOnWriteArrayList_SynchronizedList]
2.  [如果非要在多线程中使用 ArrayList 会发生什么？][ArrayList]
3.  [Why is Java Vector (and Stack) class considered obsolete or deprecated?][Why is Java Vector _and Stack_ class considered obsolete or deprecated]
4.  [In java, Vector and Collections.synchronizedList are all synchronized, what’s the difference?][In java_ Vector and Collections.synchronizedList are all synchronized_ what_s the difference]

--------------------

你好，我是看山，公众号：看山的小屋，10 年老猿，Apache Storm、WxJava、Cynomys 开源贡献者。游于码界，戏享人生。

个人主页：[https://www.howardliu.cn][https_www.howardliu.cn]  
个人博文：[Java 中 Vector 和 Collections.synchronizedList(new ArrayList()) 的区别][Java _ Vector _ Collections.synchronizedList_new ArrayList_]  
CSDN 主页：[http://blog.csdn.net/liuxinghao][http_blog.csdn.net_liuxinghao]  
CSDN 博文：[Java 中 Vector 和 Collections.synchronizedList(new ArrayList()) 的区别][Java _ Vector _ Collections.synchronizedList_new ArrayList_ 1]

![公众号：看山的小屋][21785bb43b333b0ff8efda479e715378.png]

[Java _ Vector _ SynchronizedList]: /images/20210923/4a21cca993d64b78b94ab6c7e96d628f.png
[Vector_ArrayList_CopyOnWriteArrayList_SynchronizedList]: https://www.howardliu.cn/understanding-java-list/
[ArrayList]: https://www.howardliu.cn/arraylist-is-not-thread-safe/
[Why is Java Vector _and Stack_ class considered obsolete or deprecated]: https://stackoverflow.com/questions/1386275/why-is-java-vector-and-stack-class-considered-obsolete-or-deprecated
[In java_ Vector and Collections.synchronizedList are all synchronized_ what_s the difference]: https://stackoverflow.com/questions/14932034/in-java-vector-and-collections-synchronizedlist-are-all-synchronized-whats-th
[https_www.howardliu.cn]: https://www.howardliu.cn
[Java _ Vector _ Collections.synchronizedList_new ArrayList_]: https://www.howardliu.cn/java-vector-vs-collections-synchronizedlist-arraylist/
[http_blog.csdn.net_liuxinghao]: http://blog.csdn.net/liuxinghao
[Java _ Vector _ Collections.synchronizedList_new ArrayList_ 1]: https://blog.csdn.net/liuxinghao/article/details/114238758
[21785bb43b333b0ff8efda479e715378.png]: /images/20210923/0d44d718266548a3a42d57ec7fc5eb06.png