[Java 并发编程实战] 同步容器类潜在的问题(含实例代码)
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[Java 并发编程实战] 同步容器类潜在的问题(含实例代码)相关的知识,希望对你有一定的参考价值。
路漫漫其修远兮,吾将上下而求索。———屈原《离骚》
PS: 如果觉得本文有用的话,请帮忙点赞,留言评论支持一下哦,您的支持是我最大的动力!谢谢啦~
本篇文章主要讲同步容器类存在的潜在问题以及解决办法。我们不禁想问,同步容器就一定是真正地完全线程安全吗?不一定。因为它可能会抛出下面这两种异常。
ArrayIndexOutBoundsException 异常
ConcurrentModificationException 异常
恩,这篇我们就来讨论这两个异常出现的原因以及解决办法。
同步策略
好,现在再来看上一篇文章中说到的同步容器类,先来了解它们的同步策略。它们主要有:
HashTable
Vector
Stack
同步包装器 : [ Collections.synchronizedMap(), Collections.synchronizedList() ]
Vector 的部分源码如下:
1 //...
2 public synchronized E get(int index) {
3 if (index >= elementCount)
4 throw new ArrayIndexOutOfBoundsException(index);
5
6 return elementData(index);
7 }
8
9 public synchronized E set(int index, E element) {
10 if (index >= elementCount)
11 throw new ArrayIndexOutOfBoundsException(index);
12
13 E oldValue = elementData(index);
14 elementData[index] = element;
15 return oldValue;
16 }
17
18 public synchronized boolean add(E e) {
19 modCount++;
20 ensureCapacityHelper(elementCount + 1);
21 elementData[elementCount++] = e;
22 return true;
23 }
24 //...
通过同步容器的源码可以看出,它们将状态封装起来,对每个方法都采用 synchronized 进行同步,每次只有一个线程能访问容器。
ArrayIndexOutBoundsException 异常
同步容器类理论上都是线程安全的,但是在某些情况下,依然会出错。我们用 Vector 来举例,比方现在要删除 Vector 里面的最后一个元素。如果此时有多个线程并发执行这一删除操作,能正常执行吗?
1import java.util.Vector;
2
3public class VectorTest {
4
5 //定义删除最后一个元素的方法
6 public static void deleteLast(Vector list) {
7 int lastindex = list.size() - 1;
8 list.remove(lastindex);
9 }
10
11 public static void main(String[] args) {
12
13 Vector v = new Vector(); //创建一个 Vector
14
15 //添加 10000 个元素到容器
16 for(int i = 0; i < 10000; i++) {
17 v.add(i);
18 }
19
20 //启动 N 个线程执行删除操作
21 for(int i = 0; i < 900; i++) {
22 new Thread(new Runnable() {
23 @Override
24 public void run() {
25 deleteLast(v);//删除最后一个元素
26 }
27 }).start();
28 }
29 System.out.println("end");
30 }
31}
执行结果:
执行结果是抛出异常[ArrayIndexOutBoundsException],数组下标越界。因为在这个程序中,Vector 的 size 是不断减小的。可能一个元素已经被删除的,另一个元素有再去删除它然而元素已经不存在了,所以抛出异常。
当然,这种情况我们只能通过客户端加锁来解决,好在 Vector 的同步策略就是用自己的内置锁。所以我们的代码修改如下,便可以运行:
1synchronized (v) {
2 deleteLast(v);//删除最后一个元素
3}
4
5//迭代的时候也应当注意加锁
6synchronized (v) {
7 for(int i = 0; i < v.size(); i++) {
8 doSomeThing(v.get(i));
9 }
10}
ConcurrentModificationException 异常
再来看下面一段代码:
1import java.util.Iterator;
2import java.util.Vector;
3
4public class VectorTest {
5
6 public static void main(String[] args) {
7
8 Vector v = new Vector(); //创建一个 Vector
9
10 //添加 100 个元素到容器
11 for(int i = 0; i < 100; i++) {
12 v.add(i);
13 }
14
15 //利用迭代器遍历,在遍历的同时删除一个元素
16 Iterator it = v.iterator();
17 while(it.hasNext()) {
18 Integer integer = (Integer) it.next();
19 if(integer == 5) {
20 v.remove(integer); //删除一个元素
21 }
22 }
23
24 System.out.println(v.toString());
25 }
26}
执行结果是:
在 checkForComodification 中,it.next() 会检查这两个变量(modCount、expectedModCount) 是否相等,不等则抛出这个异常。直接调用 v.remove() ,它会更新 modCount 的值,却没有更新 expectedModCount 的值,所以抛出异常。这两个变量在容器类的位置如下所示:
modCount
要解决这个问题,把 v.remove(integer) 改为使用迭代器删除 it.remove() 即可,迭代器中的方法能够同时更新这两个值,确保相等。有兴趣的朋友可以查看 Itr 的源码看个究竟。
1if(integer == 5) {
2 it.remove(); //用迭代器遍历,则用迭代器删除
3}
上面说的是单线程的情况下发生异常。那么问题来了,按照上面改好后,多线程的情况下是不是否万事大吉了呢?
答案是否定的。因为多线程情况下,不同线程的操作可能导致这两个变量在不同线程读到的值会不相等,因为这两个变量不是 volatile 变量,所以在多线程之间可能存在不可见性。
就多线程的情况,我们再来看下面一个例子:
1import java.util.Iterator;
2import java.util.Vector;
3
4public class VectorTest {
5
6 public static void main(String[] args) {
7
8 Vector v = new Vector(); //创建一个 Vector
9
10 //添加 100 个元素到容器
11 for(int i = 0; i < 100; i++) {
12 v.add(i);
13 }
14 //创建一个线程,遍历 Vector
15 new Thread(new Runnable() {
16 @Override
17 public void run() {
18 Iterator it = v.iterator();
19 while(it.hasNext()) {
20 Integer integer = (Integer) it.next(); //调用next
21 try {
22 Thread.sleep(100); //睡眠
23 } catch (InterruptedException e) {
24 // TODO Auto-generated catch block
25 e.printStackTrace();
26 }
27 }
28 }
29 }).start();
30 //创建一个线程,遍历 Vector
31 new Thread(new Runnable() {
32 @Override
33 public void run() {
34 //利用迭代器遍历,在遍历的同时删除一个元素
35 Iterator it = v.iterator();
36 while(it.hasNext()) {
37 Integer integer = (Integer) it.next();
38 if(integer == 5) {
39 it.remove(); //删除一个元素,更新变量 modCount,expectedModCount的值。
40 }
41 }
42 }
43 }).start();
44 }
45}
执行结果如下:
在对 Vector 等同步容器进行并发迭代修改的时候,迭代器就可能报 ConcurrentModificationException 异常。
针对多线程的情况,为了避免出现异常,一般有2种解决办法:
1)在使用iterator迭代的时候使用synchronized或者Lock进行同步;
2)使用并发容器CopyOnWriteArrayList代替ArrayList和Vector。
现在通过客户端加锁来举例解决,每个线程在迭代期间持有一个容器锁。
1//利用迭代器遍历,在遍历的同时删除一个元素
2synchronized(v) {
3Iterator it = v.iterator();
4while(it.hasNext()) {
5 Integer integer = (Integer) it.next();
6 if(integer == 5) {
7 it.remove(); //删除一个元素,更新变量 modCount,expectedModCount的值。
8 }
9}
隐藏的迭代器
尽管加锁可以避免迭代器出现 modCount 异常,但是必须记住在一个可能发生迭代的共享容器中,各处都要使用锁。因为有时候,迭代器是隐藏的。
比如标准容器中的 toString() 实现会迭代容器中的每个元素。类似的,容器的hashCode,equal,containsAll,removeAll和retainAIl等方法,都会对容器进行迭代,抛出ConcurrentModificationException。
这是我们应该注意的地方。
好了,今天就写到这,关于并发容器的内容将在下一篇文章中讲述。
本文完结,如对你有帮助,欢迎关注我,谢谢啦~
以上是关于[Java 并发编程实战] 同步容器类潜在的问题(含实例代码)的主要内容,如果未能解决你的问题,请参考以下文章
[Java 并发编程实战] 集合框架之 同步容器类 & 并发容器类