线程安全的集合类(java并发编程第5章)

synchronized集合

java集合框架提供了多种synchronized集合, 比如Vector, HashTable, Collections的synchronizedXxx方法的返回值等.

synchronized集合是线程安全的, 但不是严格线程安全的. 根据JCIP第二章关于线程安全的定义--线程安全的类无需调用方进行额外的同步--synchronized集合是不满足该定义的. 如果我们将线程安全的定义放宽一些--单次调用对象的方法而无需调用方进行额外的同步, 这样synchronized集合就符合定义了.

为什么要加上单次调用的限定呢? 先看一个例子:

Java代码  

1. public static Object getLast(Vector list) {   
2.     int lastIndex = list.size() - 1;   
3.     return list.get(lastIndex);   
4. }   
5.   
6. public static void deleteLast(Vector list) {   
7.     int lastIndex = list.size() - 1;   
8.     list.remove(lastIndex);   
9. }  

假设Vector对象中含有10个元素, 多线程环境下可能出现这样的场景:

线程1调用getLast方法, 计算得知lastIndex为9, 然后线程失去CPU使用权. 接着线程2调用deleteLast方法, 其lastIndex也为9, 线程2删除了第9个元素. 然后线程1重新获得CPU时间, 线程1会试图获取第9个元素, 但是该元素已经被线程2删除了, 此时将抛出ArrayIndexOutOfBoundsException异常.

从上面的例子可知, 尽管Vector对象是线程安全的, 但是如果对其进行复合操作的话(getLast方法既需要取得最后一个元素的索引, 还需要取得最后一个元素的值--类似这样的操作成为复合操作), 仍然需要调用方同步. 正确的做法应该是:

Java代码  

1. public static Object getLast(Vector list) {  
2.     synchronized (list) {  
3.         int lastIndex = list.size() - 1;  
4.         return list.get(lastIndex);  
5.     }  
6. }  
7.   
8. public static void deleteLast(Vector list) {  
9.     synchronized (list) {  
10.         int lastIndex = list.size() - 1;  
11.         list.remove(lastIndex);  
12.     }  
13. }  

之所以用Vector对象做锁, 是因为Vector类的所有方法都是同步方法(其锁为this), 这样调用方使用的锁就同Vector内部使用的锁保持一致了.

迭代是最常见的复合操作, 迭代时调用方也需要进行额外的同步, 以保证整个迭代期间集合没有发生变化. 如:

Java代码  

1. List list = Collections.synchronizedList(new ArrayList());  
2. // ...  
3. synchronized (list) {  
4.     Iterator i = list.iterator(); // Must be in synchronized block  
5.     while (i.hasNext())  
6.         foo(i.next());  
7. }   

 

ConcurrentModificationException异常和Fail-Fast机制

迭代集合时, 可能会发生ConcurrentModificationException异常. 每个集合内部都拥有一个名为modCount的成员变量, 如果集合发生了变化, 就会更改modCount的值. 使用Iterator开始迭代时，会将modCount的赋值给expectedModCount, 在迭代过程中, 通过每次比较两者是否相等来判断集合是否在内部或被其它线程修改. 如果expectedModCount和modCount不相等, 将抛出ConcurrentModificationException异常:

Java代码  

1. if (modCount != expectedModCount)  
2.         throw new ConcurrentModificationException();   

modCount被声明为volatile, 保证了线程可见性. 单线程环境下迭代时也有可能抛出ConcurrentModificationException异常, 比如在迭代时进行了会更改modCount值的操作:

Java代码  

1. Iterator<Integer> it = list.iterator();  
2. while(it.hasNext()) {  
3.     System.out.println(it.next());  
4.     // remove操作会导致modCount的值被修改, 从而引发ConcurrentModificationException异常  
5.     list.remove(0);  
6. }  

java集合类采用的这种机制被称为Fail-Fast机制--检查状态, 如果没有问题则忽略, 如果有问题就抛出异常. java集合采用这种方式避免同步所带来的开销, 如果确实需要同步, 可以使用synchronized集合, 或者在调用方进行, 或者先同步的clone一份集合然后对clone集合进行迭代--开发者可以进行选择. 使用clone的方式进行迭代的例子:

Java代码  

1. ArrayList<Integer> listClone = null;  
2. // clone时依然需要同步  
3. synchronized (list) {  
4.     listClone = (ArrayList<Integer>) list.clone();  
5. }  
6. Iterator<Integer> it = listClone.iterator();  
7. while (it.hasNext()) {  
8.     doSomething(it.next());  
9. }  

采用clone的方式进行迭代是否合适, 取决于很多因素. 比如集合的size, doSomething的调用时间, 迭代的相对频率等. 如果doSomething方法的调用时间很长, 那么使用clone是比较合适的.

除了显式迭代之外, 调用集合的toString, containsAll, removeAll和retainAll等方法也会导致迭代发生.

 

concurrent集合

Collections.synchronizedXxx方法返回synchronized集合, 查看源码可知, 返回的Synchronized集合对象只是一个包装者, 其对每一个方法都进行同步. 如:

Java代码  

1. class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> {  
2.     static final long serialVersionUID = -7754090372962971524L;  
3.   
4.     final List<E> list;  
5.   
6.     SynchronizedList(List<E> list) {  
7.         super(list);  
8.         this.list = list;  
9.     }  
10.   
11.     SynchronizedList(List<E> list, Object mutex) {  
12.         super(list, mutex);  
13.         this.list = list;  
14.     }  
15.   
16.     public boolean equals(Object o) {  
17.         synchronized (mutex) {  
18.             return list.equals(o);  
19.         }  
20.     }  
21.   
22.     public int hashCode() {  
23.         synchronized (mutex) {  
24.             return list.hashCode();  
25.         }  
26.     }  
27.   
28.     public E get(int index) {  
29.         synchronized (mutex) {  
30.             return list.get(index);  
31.         }  
32.     }  
33.     // ....  
34. }  

这样的做法对性能有很大的影响, 比如多个线程的并发读操作并不会引起并发错误, 但在Synchronized集合中只能一个线程一个线程的读. 除此之外, javadoc明确要求使用Collections.synchronizedXxx包装一个集合对象后, 就不应该使用原有的集合, 因为使用原有的集合会破坏线程安全. 这样的线程安全依赖于约定, 是不可靠的.

jdk5及后续的版本增加了ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue, ConcurrentSkipListMap, ConcurrentSkipListSet等concurrent集合类.