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

矫情吗；* 2022-07-12 04:15 174阅读 0赞

synchronized集合

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

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

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

Java代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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

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

Java代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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集合类.

[icon_star.png]: /images/20220711/aa7078777afe4f03b63228921b4a0954.png

发表评论取消回复

表情：

评论列表（有 0 条评论，174人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java并发编程：线程安全类的使用示例

在Java并发编程中，我们经常需要创建线程安全（Thread-Safe）的类。这些类可以避免多线程环境中的数据竞争问题。以下是一个简单的线程安全类（`ConcurrentC

偏执的太偏执、/ 2024年12月10日 16:27/ 0 赞/ 14 阅读

相关 Java并发编程：线程安全的类使用示例

在Java中，线程安全（Thread-Safe）是指一个类在多线程环境下执行时不会出现数据不一致的情况。以下是一些线程安全的类使用示例： 1. `synchronized`关

「爱情、让人受尽委屈。」/ 2024年12月09日 22:45/ 0 赞/ 16 阅读

相关并发编程：线程安全的Java类实例示例

在Java中，线程安全是指一个方法或者数据结构，当多线程同时访问时，不会出现数据不一致的问题。下面是一个使用Java 8的`Stream`和`Synchronized`来创

缺乏、安全感/ 2024年12月04日 12:12/ 0 赞/ 14 阅读

相关 Java并发编程：线程安全类实例分析

Java并发编程中，线程安全是指当多个线程访问某个类时，这个类仍然能够表现出正确的行为。为了实现线程安全，Java提供了多种机制，包括同步、锁、原子变量等。以下是一些Java中

待我称王封你为后i/ 2024年11月14日 08:21/ 0 赞/ 13 阅读

相关 Java并发编程：线程安全类实例分析

在Java并发编程中，线程安全类是指那些在多线程环境下使用时，能保证数据正确性的类。下面我们将通过几个实例来分析线程安全类的使用和理解。 1. **同步容器** (如`syn

逃离我推掉我的手/ 2024年10月22日 17:48/ 0 赞/ 35 阅读

相关 Java并发编程：线程安全的类实例

在Java中，线程安全的类是指那些无论何时被多个线程访问，都能保证数据一致性的类。以下是一些Java内置的线程安全类： 1. `ConcurrentHashMap`：键值

灰太狼/ 2024年10月06日 10:57/ 0 赞/ 68 阅读

相关多线程并发操作：Java集合类线程安全问题

在Java中，当多个线程同时访问和修改一个共享的集合（如List、Set或Map）时，可能会出现线程安全问题。 1. **竞态条件**：多个线程同时访问某个元素，可能因为数据

﹏ヽ暗。殇╰゛Y/ 2024年09月22日 12:27/ 0 赞/ 77 阅读

相关 Java集合类线程安全

文章目录 ArrayList线程不安全 List线程安全解决方案 HashSet线程不安全 hashMap线程不安全 ArrayList

「爱情、让人受尽委屈。」/ 2022年09月06日 01:19/ 0 赞/ 254 阅读

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

synchronized集合 java集合框架提供了多种synchronized集合, 比如Vector, HashTable, Collections的synchroniz

矫情吗；*/ 2022年07月12日 04:15/ 0 赞/ 175 阅读

相关《Java并发编程实战》读书笔记-第2章线程安全

1，什么是线程安全的？当多个线程访问某个类时，不管运行时环境彩何种调试方式或者这些线程如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为

向右看齐/ 2022年07月11日 04:58/ 0 赞/ 247 阅读