路漫漫其修远兮，吾将上下而求索。———屈原《离骚》
本篇文章主要讲同步容器类存在的潜在问题以及解决办法。我们不禁想问，同步容器就一定是真正地完全线程安全吗？不一定。因为它可能会抛出下面这两种异常。
- ArrayIndexOutBoundsException 异常
- ConcurrentModificationException 异常
恩，这篇我们就来讨论这两个异常出现的原因以及解决办法。
同步策略
好，现在再来看上一篇文章中说到的同步容器类，先来了解它们的同步策略。它们主要有：
- HashTable
- Vector
- Stack
- 同步包装器 : [ Collections.synchronizedMap(), Collections.synchronizedList() ]
Vector 的部分源码如下：
//...
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
public synchronized E set(int index, E element) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
//...
通过同步容器的源码可以看出，它们将状态封装起来，对每个方法都采用 synchronized 进行同步，每次只有一个线程能访问容器。
ArrayIndexOutBoundsException 异常
同步容器类理论上都是线程安全的，但是在某些情况下，依然会出错。我们用 Vector 来举例，比方现在要删除 Vector 里面的最后一个元素。如果此时有多个线程并发执行这一删除操作，能正常执行吗？
import java.util.Vector;
public class VectorTest {
//定义删除最后一个元素的方法
public static void deleteLast(Vector list) {
int lastindex = list.size() - 1;
list.remove(lastindex);
}
public static void main(String[] args) {
Vector v = new Vector(); //创建一个 Vector
//添加 10000 个元素到容器
for(int i = 0; i < 10000; i++) {
v.add(i);
}
//启动 N 个线程执行删除操作
for(int i = 0; i < 900; i++) {
new Thread(new Runnable() {
@Override
public void run() {
deleteLast(v);//删除最后一个元素
}
}).start();
}
System.out.println("end");
}
}
执行结果：
执行结果是抛出异常[ArrayIndexOutBoundsException]，数组下标越界。因为在这个程序中，Vector 的 size 是不断减小的。可能一个元素已经被删除的，另一个元素有再去删除它然而元素已经不存在了，所以抛出异常。
当然，这种情况我们只能通过客户端加锁来解决，好在 Vector 的同步策略就是用自己的内置锁。所以我们的代码修改如下，便可以运行：
synchronized (v) {
deleteLast(v);//删除最后一个元素
}
//迭代的时候也应当注意加锁
synchronized (v) {
for(int i = 0; i < v.size(); i++) {
doSomeThing(v.get(i));
}
}
ConcurrentModificationException 异常
再来看下面一段代码：
import java.util.Iterator;
import java.util.Vector;
public class VectorTest {
public static void main(String[] args) {
Vector v = new Vector(); //创建一个 Vector
//添加 100 个元素到容器
for(int i = 0; i < 100; i++) {
v.add(i);
}
//利用迭代器遍历，在遍历的同时删除一个元素
Iterator it = v.iterator();
while(it.hasNext()) {
Integer integer = (Integer) it.next();
if(integer == 5) {
v.remove(integer); //删除一个元素
}
}
System.out.println(v.toString());
}
}
执行结果是：
在 checkForComodification 中，it.next() 会检查这两个变量(modCount、expectedModCount) 是否相等，不等则抛出这个异常。直接调用 v.remove() ，它会更新 modCount 的值，却没有更新 expectedModCount 的值，所以抛出异常。这两个变量在容器类的位置如下所示：
要解决这个问题，把 v.remove(integer) 改为使用迭代器删除 it.remove() 即可，迭代器中的方法能够同时更新这两个值，确保相等。有兴趣的朋友可以查看 Itr 的源码看个究竟。
if(integer == 5) {
it.remove(); //用迭代器遍历，则用迭代器删除
}
上面说的是单线程的情况下发生异常。那么问题来了，按照上面改好后，多线程的情况下是不是否万事大吉了呢？
答案是否定的。因为多线程情况下，不同线程的操作可能导致这两个变量在不同线程读到的值会不相等，因为这两个变量不是 volatile 变量，所以在多线程之间可能存在不可见性。
就多线程的情况，我们再来看下面一个例子：
import java.util.Iterator;
import java.util.Vector;
public class VectorTest {
public static void main(String[] args) {
Vector v = new Vector(); //创建一个 Vector
//添加 100 个元素到容器
for(int i = 0; i < 100; i++) {
v.add(i);
}
//创建一个线程，遍历 Vector
new Thread(new Runnable() {
@Override
public void run() {
Iterator it = v.iterator();
while(it.hasNext()) {
Integer integer = (Integer) it.next(); //调用next
try {
Thread.sleep(100); //睡眠
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}).start();
//创建一个线程，遍历 Vector
new Thread(new Runnable() {
@Override
public void run() {
//利用迭代器遍历，在遍历的同时删除一个元素
Iterator it = v.iterator();
while(it.hasNext()) {
Integer integer = (Integer) it.next();
if(integer == 5) {
it.remove(); //删除一个元素,更新变量 modCount，expectedModCount的值。
}
}
}
}).start();
}
}
执行结果如下：
在对 Vector 等同步容器进行并发迭代修改的时候，迭代器就可能报 ConcurrentModificationException 异常。
针对多线程的情况，为了避免出现异常，一般有2种解决办法：
1）在使用iterator迭代的时候使用synchronized或者Lock进行同步；
2）使用并发容器CopyOnWriteArrayList代替ArrayList和Vector。
现在通过客户端加锁来举例解决，每个线程在迭代期间持有一个容器锁。
//利用迭代器遍历，在遍历的同时删除一个元素
synchronized(v) {
Iterator it = v.iterator();
while(it.hasNext()) {
Integer integer = (Integer) it.next();
if(integer == 5) {
it.remove(); //删除一个元素,更新变量 modCount，expectedModCount的值。
}
}
隐藏的迭代器
尽管加锁可以避免迭代器出现 modCount 异常，但是必须记住在一个可能发生迭代的共享容器中，各处都要使用锁。因为有时候，迭代器是隐藏的。
比如标准容器中的 toString() 实现会迭代容器中的每个元素。类似的，容器的hashCode，equal，containsAll，removeAll和retainAIl等方法，都会对容器进行迭代，抛出ConcurrentModificationException。
这是我们应该注意的地方。
好了，今天就写到这，关于并发容器的内容将在下一篇文章中讲述。