ArrayList是非线程安全的，在多线程中同时操作ArrayList会经常出现ConcurrentModificationException。为了解决同步问题，java提供了Collections的同步类：SynchronizedList、SynchronizedMap、SynchronizedSet等。以SynchronizedList为例，从字面意义上看，应该是线程安全的。在我们的代码中，我们使用了SynchronizedList，初始代码如下：
List list = Collections.synchronizedList(new ArrayList());
在运用过程中，不对该List加锁处理。APP上线后，定时查看后台返回的crash信息，发现对该list的操作依然出现了ConcurrentModificationException。crash信息中显示该异常发生在执行for循环时：
for(Object object : list){
....
}
错误的最后一句执行代码为：java.util.ArrayList$Itr.next(ArrayList.java:831)
看来SynchronizedList并不像想象的那样绝对保证线程安全，那问题如何出现的呢？
先从增强for循环的实现说起。
增强for循环是基于迭代器实现的，如原始代码为：
for (Integer i : list) {
System.out.println(i);
}
反编译后，可以看到如下代码：
Integer i;
for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(i)){
i = (Integer)iterator.next();
}
而我们的crash最后一句就是java.util.ArrayList$Itr.next(ArrayList.java:831)。
按照java的fail-fast机制中的介绍：
Iterator是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出java.util.ConcurrentModificationException异常。
最终判断出使用的SynchronizedList在遍历过程中其List出现了内容的变更。
为了确定问题所在，我们应该去看SynchronizedList的源码：
static class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;
final List<E> list;
SynchronizedList(List<E> l) {
super(l);
list = l;
}
SynchronizedList(List<E> l, Object mutex) {
super(l, mutex);
list = l;
}
@Override public void add(int location, E object) {
synchronized (mutex) {
list.add(location, object);
}
}
@Override public boolean addAll(int location, Collection<? extends E> collection) {
synchronized (mutex) {
return list.addAll(location, collection);
}
}
@Override public boolean equals(Object object) {
synchronized (mutex) {
return list.equals(object);
}
}
@Override public E get(int location) {
synchronized (mutex) {
return list.get(location);
}
}
@Override public int hashCode() {
synchronized (mutex) {
return list.hashCode();
}
}
@Override public int indexOf(Object object) {
final int size;
final Object[] array;
synchronized (mutex) {
size = list.size();
array = new Object[size];
list.toArray(array);
}
if (object != null) {
for (int i = 0; i < size; i++) {
if (object.equals(array[i])) {
return i;
}
}
} else {
for (int i = 0; i < size; i++) {
if (array[i] == null) {
return i;
}
}
}
return -1;
}
@Override public int lastIndexOf(Object object) {
final int size;
final Object[] array;
synchronized (mutex) {
size = list.size();
array = new Object[size];
list.toArray(array);
}
if (object != null) {
for (int i = size - 1; i >= 0; i--) {
if (object.equals(array[i])) {
return i;
}
}
} else {
for (int i = size - 1; i >= 0; i--) {
if (array[i] == null) {
return i;
}
}
}
return -1;
}
@Override public ListIterator<E> listIterator() {
synchronized (mutex) {
return list.listIterator();
}
}
@Override public ListIterator<E> listIterator(int location) {
synchronized (mutex) {
return list.listIterator(location);
}
}
@Override public E remove(int location) {
synchronized (mutex) {
return list.remove(location);
}
}
@Override public E set(int location, E object) {
synchronized (mutex) {
return list.set(location, object);
}
}
@Override public List<E> subList(int start, int end) {
synchronized (mutex) {
return new SynchronizedList<E>(list.subList(start, end), mutex);
}
}
private void writeObject(ObjectOutputStream stream) throws IOException {
synchronized (mutex) {
stream.defaultWriteObject();
}
}
/**
* Resolves SynchronizedList instances to SynchronizedRandomAccessList
* instances if the underlying list is a Random Access list.
* <p>
* This is necessary since SynchronizedRandomAccessList instances are
* replaced with SynchronizedList instances during serialization for
* compliance with JREs before 1.4.
* <p>
*
* @return a SynchronizedList instance if the underlying list implements
* RandomAccess interface, or this same object if not.
*
* @see SynchronizedRandomAccessList#writeReplace()
*/
private Object readResolve() {
if (list instanceof RandomAccess) {
return new SynchronizedRandomAccessList<E>(list, mutex);
}
return this;
}
}
从源码中我们可以看到SynchronizedList是通过对mutex做同步来控制线程安全的，而mutex定义在其父类SynchronizedCollection中。
SynchronizedCollection(Collection<E> collection) {
c = collection;
mutex = this;
}
SynchronizedCollection(Collection<E> collection, Object mutex) {
c = collection;
this.mutex = mutex;
}
从源码中，我们发现了add、remove等操作都是线程安全的，加锁的对象默认是this，也即是list本身。但是没有针对Iterator.next做同步处理。所以整个for循环是非线程安全的。
另外，需要注意的是add、remove等操作仅是方法安全，如果在使用过程中执行如下代码：
list.add(object1);
list.remove(object1);
此代码并非原子操作，任何线程都可能在add和remove之间抢夺mutex。
找到了问题，那如何解决呢？上面描述中，SynchronizedList默认以List本身做为锁对象，所以只需要在遍历的代码中对本身list做synchronized处理即可。或者自定义mutex。
---------------------
作者：hanzengbo2017
来源：CSDN
原文：https://blog.csdn.net/hanzengbo2017/article/details/77801110
版权声明：本文为博主原创文章，转载请附上博文链接！
