Java容器线程安全

发表于2015-11-09
评论1 583浏览

想免费获取内部独家PPT资料库?观看行业大牛直播?点击加入腾讯游戏学院游戏程序行业精英群

711501594

同步容器类

同步容器类包括Vector和Hashtable(二者是早期JDK的一部分),还包括JDK1.2中添加的一些相似的类。同步容器类实现线程安全的方式是:将状态封闭起来,并对每个公有方法进行同步,使得每次只有一个线程能访问容器状态。这里解释一下所谓“状态”指的就是成员变量,“封装起来”即将它们设不private,但是通过公有的方法外界仍然可以访问修改类的私有成员,所以要用synchronized将公有方法进行同步,使得每次只有一个线程能访问容器状态。在多线程环境下调用同步容器类自带的所有方法时,实际上都是在串行执行,所以这严重降低并发性和吞吐量。

像List、Set、Map这些原本不是同步容器类,也可以通过Collections.synchronizedXXX工厂方法将其变为同步容器类,即对其公有方法进行同步。

[java]  view plain copy print ?
  1. List<Student> students=Collections.synchronizedList(new ArrayList<Student>());  

同步容器类的问题

容器上常见的操作包括:迭代访问、跳转(根据指定顺序找到当前元素的下一个元素)、条件运算(先检查再操作Check-And-Act,比如若没有则添加)。

[java]  view plain copy print ?
  1. public static Object getLast(Vector vec){  
  2.     int lastIndex=vec.size()-1;  
  3.     return vec.get(lastIndex);  
  4. }  
  5. public static Object deleteLast(Vector vec){  
  6.     int lastIndex=vec.size()-1;  
  7.     return vec.remove(lastIndex);  
  8. }  
大线程的环境下,getLast()函数中第一行代码之后第二行代码之前如果执行了deleteLast(),那么 getLast()继续执行第二行就会抛出ArrayIndexOutOfBoundException。所以要把getLast()和deleteLast()都变成原子操作:

[java]  view plain copy print ?
  1. public static Object getLast(Vector vec){  
  2.     synchronized(vec){  
  3.         int lastIndex=vec.size()-1;  
  4.         return vec.get(lastIndex);  
  5.     }  
  6. }  
  7. public static Object deleteLast(Vector vec){  
  8.     synchronized(vec){  
  9.         int lastIndex=vec.size()-1;  
  10.         return vec.remove(lastIndex);  
  11.     }  
  12. }  
又比如容器上的迭代操作:

[java]  view plain copy print ?
  1. for(int i=0;i<vec.size();i++)  
  2.     doSomething(vec.get(i));  
在size()之后get()之前,其他线程可能删除了vec中的元素,同样会导致抛出 ArrayIndexOutOfBoundException。但这并不意味着Vector不是线程安全的,Vector的状态仍然是有效的,而抛出的异常也与其规范保持一致。

正确的做法是在迭代之前对vector加锁:

[java]  view plain copy print ?
  1. synchronized(vec){  
  2.     for(int i=0;i<vec.size();i++)  
  3.         doSomething(vec.get(i));  
  4. }  

迭代器与ConcurrentModificationException

使用for或for-each循环对容器进行迭代时,javac内部都会转换成使用Iterator。在对同步容器类进行迭代时如果发现元素个数发生变化,那么hasNext和next将抛出ConcurrentModificationException这被称为及时失效(fail-fast)。

[java]  view plain copy print ?
  1. List<Student> students=Collections.synchronizedList(new ArrayList<Student>());  
  2. //可能抛出ConcurrentModificationException  
  3. for(Student student:students)  
  4.     doSomething(student);  
为了防止抛出ConcurrentModificationException,需要在迭代之前对容器进行加锁,但是如果doSomething()比较耗时,那么其他线程都在等待锁,会极大降低吞吐率和CPU的利用率。不加锁的解决办法是“克隆”容器,在副本上进行迭代,由于副本被封闭在线程内,其他线程不会在迭代期间对其进行修改。克隆的过程也需要对容器加锁,开发人员要做出权衡,因为克隆容器本身也有显著的性能开销。

隐藏的迭代器

注意,下面的情况会间接地进行迭代操作,也会抛出ConcurrentModificationException:

  1. 容器的toString()、hashCode()和equals()方法
  2. containsAll()、removeAll()、retainAll()等方法
  3. 调用以上方法的方法,比如StringBuildre.append(Object)会调用toString()
  4. 容器作为另一个容器的元素或者键
  5. 把容器作为参数的构造函数
扯句不相关的话,编译器会把字符串的连接操作转换为调用StringBuildre.append(Object)。《Effective Java》也提出当使用多个"+"进行字符串连接时考虑使用StringBuildre.append()代替,因为每次“+”操作都要完全地拷贝2个字符串,而StringBuilder.append()是在第一个字符串后面连接第2个字符串,跟C++中的Vector是一个原理。

并发容器

同步容器将对状态的访问都串行化,以实现他们的线程安全性。这样做的代价是严重降低了并发性和吞吐量。
并发容器类提供的迭代器不会抛出ConcurrentModificationException,因此不需要在迭代时对容器进行加锁。
下面介绍Java5.0中新增加的几个并发容器类。

并发Map

同步容器类在执行每个操作期间都加了一个锁,在一些操作中例如HashMap.get()可能包含大量的工作,如何hashCode不能均匀地分布散列值,那就需要在很多元素上调用equals,而equals本身就有一定的计算量。 HashMap将每个方法都在同一个锁上同步使得每次只能有一个线程访问容器,ConcurrentHashMap与HashMap不同,它采用了粒度更细的分段锁(Lock Striping)。 结果是任意的读线程可以并发地访问Map,读线程和写线程可以并发地访问Map,一定数量的写线程可以并发地访问Map。而且在单线程的环境下,ConcurrentHashMap比HashMap性能损失很小。
对于需要在整个Map进行的计算,例如size和isEmpty,ConcurrentHashMap会返回一个近似值而非精确值,因为size()返回的值在计算时可能已经过期了。
ConcurrentHashMap接口中增加了对一些常见复合操作的支持,例如“若没有则添加”、“若相等则替换”、“若相等则移除”等等,在ConcurrentMap接口中已经声明为原子操作。

Copy-On-Write容器

CopyOnWriteArrayList用于替代同步List,同理CopyOnWriteAeeaySet用于替代同步Set,这里就以 CopyOnWriteArrayList为例。 “写时复制(Copy-On-Write)”容器的线程安全性在于:只要发布一个事实不可变的对象,那么在访问对象时就不需要再进一步同步。当需要修改对象的时候都会重新复制发布一个新的容器副本。
如果一个对象在被创建之后其状态就不能被修改,那这个对象就是不可变对象。不可变对象一定是线程安全的。但要注意即使将所有域声明为final,这个对象仍然有可能是可变的,因为final域中可以保存可变对象的引用。下面举个例子,在可变对象上构建不可变类:
[java]  view plain copy print ?
  1. public final class ThreeStorage{  
  2.     private final Set<String> storages=new HashSet<String>();  
  3.     public ThreeStorage(){  
  4.         storages.add("One");  
  5.         storages.add("Two");  
  6.         storages.add("Three");  
  7.     }  
  8.     public boolean isStorage(String name){  
  9.         return storages.contains(name);  
  10.     }  
  11. }  
虽然Set对象是可变的,但从ThreeStorage的设计上来看,Set对象在构造完成后无法对其进行修改。 
每当需要修改容器时都是复制底层数组,看一下set()函数的的源代码:
[java]  view plain copy print ?
  1. public class CopyOnWriteArrayList<E>{  
  2.     private volatile transient Object[] array;  
  3.     final Object[] getArray() {  
  4.         return array;  
  5.     }  
  6.     final void setArray(Object[] a) {  
  7.         array = a;  
  8.     }  
  9.     public E set(int index, E element) {  
  10.         //获取重入锁  
  11.     final ReentrantLock lock = this.lock;  
  12.     lock.lock();  
  13.     try {  
  14.         Object[] elements = getArray();  
  15.         Object oldValue = elements[index];  
  16.                 //使用的是==而非equals  
  17.         if (oldValue != element) {  
  18.             int len = elements.length;  
  19.                         //复制底层数组  
  20.             Object[] newElements = Arrays.copyOf(elements, len);  
  21.             newElements[index] = element;  
  22.                         //把底层数组写回  
  23.             setArray(newElements);  
  24.         } else {  
  25.             setArray(elements);  
  26.         }  
  27.         return (E)oldValue;  
  28.     } finally {  
  29.                 //释放锁  
  30.         lock.unlock();  
  31.     }  
  32.     }  
  33. }  


一进入set()函数就加了锁,函数结束时才释放锁。
因为复制底层数组本身就有一定的开销,所以仅当迭代操作远远多于修改操作时,才应该使用CopyOnWrite容器。

并发Queue

基本的Collection就是List、Set和Map,Queue底层是由LinkedList来实现的,因为它去除了List的随机访问功能,因此更高效。
ConcurrentinkedQueue是一个传统的先进先出队列。PriorityQueue是一个非并发的优先队列(说这个似乎与本文的主题无关)。
Queue上的操作是阻塞的,如果队列为空,那么获取元素的操作会立即返回空值。BlockingQueue的插入和获取操作是阻塞式的,如果队列为空,那么获取操作将一直阻塞队列中有一个可用的元素;如果队列已满,那么插入操作将一直阻塞。

Sorted容器

ConcurrentSkipListMap用于替代SortedMap,ConcurrentSkipListSet用于替代SortedSet。TreeMap和TreeSet分别实现了SortedMap和SortedSet。By the way,既然是"sorted",那么这类容器的元素就必须实现Comparable接口。

原文链接

著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

如社区发表内容存在侵权行为,您可以点击这里查看侵权投诉指引

游戏学院公众号二维码
腾讯游戏学院
微信公众号

提供更专业的游戏知识学习平台