增强for循环的线程安全问题

        增强for循环在遍历集合的时候，底层是使用迭代器来实现的。当我们在for循环内部操作时，就会抛出一个异常。如下

package com.deepCopy;

import java.util.List;
import java.io.IOException;
import java.util.ArrayList;

public class Test {
	public static void main(String[] args) throws ClassNotFoundException, IOException {
		List personList=new ArrayList();
		personList.add("zhangsan");
		personList.add("lisi");
		/*for(int i=0;i

运行结果

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:819)
	at java.util.ArrayList$Itr.next(ArrayList.java:791)
	at com.deepCopy.Test.main(Test.java:17)

其实是这样的在调用迭代器的next方法时，

 @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

再来看checkForComodification方法

final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

而这两个为什么不相等呢，看add方法

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

再来看ensureCapacityInternal()这个方法

private void ensureCapacityInternal(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);

    }

终于找到了，其实add方法的时候就是通过这个变量modCount++改变，然后调用next方法进行遍历的时候，抛出异常来控制集合读的时候不能写操作，因为不是线程安全的，这个就是增强for循环的缺点.