[Java 并发编程实战] 同步容器类潜在的问题（含实例代码）

标签：同步容器   Java并发编程   同步容器问题   并发编程   

路漫漫其修远兮，吾将上下而求索。———屈原《离骚》

PS: 如果觉得本文有用的话，请帮忙点赞，留言评论支持一下哦，您的支持是我最大的动力！谢谢啦~

本篇文章主要讲同步容器类存在的潜在问题以及解决办法。我们不禁想问，同步容器就一定是真正地完全线程安全吗？不一定。因为它可能会抛出下面这两种异常。

1. ArrayIndexOutBoundsException 异常

2. 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}

执行结果：

当然，这种情况我们只能通过客户端加锁来解决，好在 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}

执行结果是：

要解决这个问题，把 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}

执行结果如下：

针对多线程的情况，为了避免出现异常，一般有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并发编程   同步容器问题   并发编程   

原文地址：http://blog.51cto.com/13760461/2124399