面试官问我同步容器（如Vector）的所有操作一定是线程安全的吗？我懵了！

 =[[275164]]

创新互联专注于保亭黎族企业网站建设,响应式网站建设,成都做商城网站。保亭黎族网站建设公司,为保亭黎族等地区提供建站服务。全流程按需策划，专业设计，全程项目跟踪，创新互联专业和态度为您提供的服务

为了方便编写出线程安全的程序，Java里面提供了一些线程安全类和并发工具，比如：同步容器、并发容器、阻塞队列等。

最常见的同步容器就是Vector和Hashtable了，那么，同步容器的所有操作都是线程安全的吗?

这个问题不知道你有没有想过，本文就来深入分析一下这个问题，一个很容易被忽略的问题。

1.同步容器

在Java中，同步容器主要包括2类：

  • 1、Vector、Stack、HashTable
  • 2、Collections类中提供的静态工厂方法创建的类

本文拿相对简单的Vecotr来举例，我们先来看下Vector中几个重要方法的源码：

 
 
 
 
    
  
  
  
  
  1. public synchronized boolean add(E e) { 
    2.   
  
  
  
  2.     modCount++; 
    3.   
  
  
  
  3.     ensureCapacityHelper(elementCount + 1); 
    4.   
  
  
  
  4.     elementData[elementCount++] = e; 
    5.   
  
  
  
  5.     return true; 
    6.   
  
  
  
  6. } 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8. public synchronized E remove(int index) { 
    9.   
  
  
  
  9.     modCount++; 
    10.   
  
  
  
  10.     if (index >= elementCount) 
    11.   
  
  
  
  11.         throw new ArrayIndexOutOfBoundsException(index); 
    12.   
  
  
  
  12.     E oldValue = elementData(index); 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.     int numMoved = elementCount - index - 1; 
    15.   
  
  
  
  15.     if (numMoved > 0) 
    16.   
  
  
  
  16.         System.arraycopy(elementData, index+1, elementData, index, 
    17.   
  
  
  
  17.                          numMoved); 
    18.   
  
  
  
  18.     elementData[--elementCount] = null; // Let gc do its work 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.     return oldValue; 
    21.   
  
  
  
  21. } 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23. public synchronized E get(int index) { 
    24.   
  
  
  
  24.     if (index >= elementCount) 
    25.   
  
  
  
  25.         throw new ArrayIndexOutOfBoundsException(index); 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27.     return elementData(index); 
    28.   
  
  
  
  28. } 
    29.

可以看到，Vector这样的同步容器的所有公有方法全都是synchronized的，也就是说，我们可以在多线程场景中放心的使用单独这些方法，因为这些方法本身的确是线程安全的。但是，请注意上面这句话中，有一个比较关键的词：单独因为，虽然同步容器的所有方法都加了锁，但是对这些容器的复合操作无法保证其线程安全性。需要客户端通过主动加锁来保证。简单举一个例子，我们定义如下删除Vector中最后一个元素方法：

 
 
 
 
    
  
  
  
  
  1. public Object deleteLast(Vector v){ 
    2.   
  
  
  
  2.     int lastIndex  = v.size()-1; 
    3.   
  
  
  
  3.     v.remove(lastIndex); 
    4.   
  
  
  
  4. } 
    5.

上面这个方法是一个复合方法，包括size()和remove()，乍一看上去好像并没有什么问题，无论是size()方法还是remove()方法都是线程安全的，那么整个deleteLast方法应该也是线程安全的。但是时，如果多线程调用该方法的过程中，remove方法有可能抛出ArrayIndexOutOfBoundsException。

 
 
 
 
    
  
  
  
  
  1. Exception in thread "Thread-1" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 879 
    2.   
  
  
  
  2.     at java.util.Vector.remove(Vector.java:834) 
    3.   
  
  
  
  3.     at com.hollis.Test.deleteLast(EncodeTest.java:40) 
    4.   
  
  
  
  4.     at com.hollis.Test$2.run(EncodeTest.java:28) 
    5.   
  
  
  
  5.     at java.lang.Thread.run(Thread.java:748) 
    6.

我们上面贴了remove的源码，我们可以分析得出：当index >= elementCount时，会抛出ArrayIndexOutOfBoundsException ，也就是说，当当前索引值不再有效的时候，将会抛出这个异常。因为removeLast方法，有可能被多个线程同时执行，当线程2通过index()获得索引值为10，在尝试通过remove()删除该索引位置的元素之前，线程1把该索引位置的值删除掉了，这时线程一在执行时便会抛出异常。

为了避免出现类似问题，可以尝试加锁：

 
 
 
 
    
  
  
  
  
  1. public void deleteLast() { 
    2.   
  
  
  
  2.     synchronized (v) { 
    3.   
  
  
  
  3.         int index = v.size() - 1; 
    4.   
  
  
  
  4.         v.remove(index); 
    5.   
  
  
  
  5.     } 
    6.   
  
  
  
  6. } 
    7.

如上，我们在deleteLast中，对v进行加锁，即可保证同一时刻，不会有其他线程删除掉v中的元素。另外，如果以下代码会被多线程执行时，也要特别注意：

 
 
 
 
    
  
  
  
  
  1. for (int i = 0; i < v.size(); i++) { 
    2.   
  
  
  
  2.     v.remove(i); 
    3.   
  
  
  
  3. } 
    4.

由于，不同线程在同一时间操作同一个Vector，其中包括删除操作，那么就同样有可能发生线程安全问题。所以，在使用同步容器的时候，如果涉及到多个线程同时执行删除操作，就要考虑下是否需要加锁。

2.同步容器的问题

前面说过了，同步容器直接保证单个操作的线程安全性，但是无法保证复合操作的线程安全，遇到这种情况时，必须要通过主动加锁的方式来实现。而且，除此之外，同步容易由于对其所有方法都加了锁，这就导致多个线程访问同一个容器的时候，只能进行顺序访问，即使是不同的操作，也要排队，如get和add要排队执行。这就大大的降低了容器的并发能力。

3.并发容器

针对前文提到的同步容器存在的并发度低问题，从Java5开始，java.util.concurent包下，提供了大量支持高效并发的访问的集合类，我们称之为并发容器。

针对前文提到的同步容器的复合操作的问题，一般在Map中发生的比较多，所以在ConcurrentHashMap中增加了对常用复合操作的支持，比如putIfAbsent()、replace()，这2个操作都是原子操作，可以保证线程安全。另外，并发包中的CopyOnWriteArrayList和CopyOnWriteArraySet是Copy-On-Write的两种实现。Copy-On-Write容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。CopyOnWriteArrayList中add/remove等写方法是需要加锁的，而读方法是没有加锁的。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，当然，这里读到的数据可能不是最新的。因为写时复制的思想是通过延时更新的策略来实现数据的最终一致性的，并非强一致性。但是，作为代替Vector的CopyOnWriteArrayList并没有解决同步容器的复合操作的线程安全性问题。

4.总结

本文介绍了同步容器和并发容器。同步容器是通过加锁实现线程安全的，并且只能保证单独的操作是线程安全的，无法保证复合操作的线程安全性。并且同步容器的读和写操作之间会互相阻塞。并发容器是Java 5中提供的，主要用来代替同步容器。有更好的并发能力。而且其中的ConcurrentHashMap定义了线程安全的复合操作。在多线程场景中，如果使用并发容器，一定要注意复合操作的线程安全问题。必要时候要主动加锁。在并发场景中，建议直接使用java.util.concurent包中提供的容器类，如果需要复合操作时，建议使用有些容器自身提供的复合方法。

创新互联成都网站建设公司，为上千家企业和品牌提供网站建站、定制网站设计、网站制作、网站策划服务;公司秉持一丝不苟、精益求精的态度,创新互联深信，为您创造更多价值的同时，亦是成就我们（cdcxhl.com）的品牌品质。

分享名称：面试官问我同步容器（如Vector）的所有操作一定是线程安全的吗？我懵了！
文章分享：http://www.shufengxianlan.com/qtweb/news3/101003.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站导航知识

各行业网站

资阳做网站　　 　成都主机托管　　 　成都温江机房　　 　专业网站建设　　 　成都服务器运维　　 　主机租用　　 　成都网站制作　　 　成都主机托管　　 　网站开发　　 　谷歌优化排名　　 　泸州网站建设　　 　营销推广　　 　机柜租用　　 　成都小程序开发公司　　 　成都网站建设　　 　温岭熙道网站　　 　成都机柜租用　　 　崇州网站建设　　 　鸿程源茂　　 　成都全网营销