Java教程

【Java笔记】以并发修改异常为例总结的出错解决办法

本文主要是介绍【Java笔记】以并发修改异常为例总结的出错解决办法,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

先来看出错代码:

/*需求:
遍历已有集合
如果在集合中发现存在字符串元素“world”
则在“world”后添加元素“javaee”
*/

List list = new ArrayList();
//多态的形式创建接口实现类对象
list.add("helllo");
list.add("java");
list.add("world");

//生成迭代器并判断有无world这个元素,如果有则向集合中添加“javaee”
Iterator it = list.iterator();
while(it.hasNext()){
    String s = it.next();
    if(s.equals("world")){
    list.add("javaee");
    }
}

System.out.println(list);
//抛出异常:ConcurrentModificationException

 

这段代码中我试图在迭代的过程中通过list(List实现类对象)调用add方法向集合中添加元素并进行输出,但编译器在输出阶段抛出异常并终止了程序运行。

错误信息如下:

下面开始分析问题并找到解决方案:

1. 在错误信息中找到异常名称,将异常名称到帮助文档查看抛出异常的原因:

2. 通过报错信息定位抛出异常的方法。

        错误信息中蓝色高亮的部分UseIterator.java:23表示的是抛出异常的方法所在行数,进一步跟进是ArrayList中的Itr内部类中调用的next方法出的问题,再进一步跟进是ArrayList中的next方法调用的checkForComodification抛出的异常。

3.源码分析(选中类名ctrl+b查看源码)

        抛出异常的代码如下:

List<String> list = new ArrayList<String>();//创建集合对象
Iterator<String> it = list.iterator();//创建迭代器实现类对象

String s = it.next();//抛出异常的代码

从上面的代码中可以看到万恶之源是这个List,所以,先要有一个List,为了看起来更简洁这里我只拿了用到的内容过来,其他在这个案例中没有用到的就暂时没有管,下面的源码也会像这样简洁的拿过来看。

public interface List<E> extends Collection<E> {
    Iterator<E> iterator();
    boolean add(E e);
}

因为list是以多态的形式创建的ArrayList对象,所以也把ArrayList拿过来看看。

public class ArrayList<E> extends AbstractList<E> implements List<E>{
    private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
        /*
            expectedModCount:预期修改值
            modCount:实际修改值(继承自父类AbstractList)
        */

        @SuppressWarnings("unchecked")
        //异常初步定位在内部类Itr的next方法中
        public E next() { 
            checkForComodification();//异常根源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];
        }

        //异常根源
        final void checkForComodification() {
            if (modCount != expectedModCount)
            //当预期修改值与实际修改值不同抛出异常
            throw new ConcurrentModificationException();
        }
    }
}

从定义中可以看到ArrayList继承了AbstractList<E>,Abstract也暂时先把定义拿过来,里面需要用到的内容后面进行完善。

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>();

  ArrayList的定义中可以看出,除了继承AbstractList<E>外,还实现了接口List<E>,所以ArrayList中应该要有add方法的实现,所以将add方法的实现也拿过来看看。

public class ArrayList<E> extends AbstractList<E> implements List<E>{
    //重写接口中的add方法
    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
         return true;
     }

    private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
        /*
            expectedModCount:预期修改值
            modCount:实际修改值(继承自父类AbstractList)
        */

        @SuppressWarnings("unchecked")
        //异常初步定位在内部类Itr的next方法中
        public E next() {
            checkForComodification();
            //异常根源checkForComodification()方法
            ...
        }

        //异常根源
        final void checkForComodification() {
            if (modCount != expectedModCount)
            //当预期修改值与实际修改值不同抛出该异常
            throw new ConcurrentModificationException();
        }
    }
}

其实到这一步基本上已经能看出来个大概了,Itr实现了List中的Iterator接口,而出错的代码中的it正是Iterator的实现类对象,这里的Itr就是这个实现类。

        Itr在实现next时调用了checkForComodification()方法将expectedModCount和modCount进行对比,如果两边不等就会抛出异常。那么现在要解决的就是expectedModCount和modCount是什么的问题了。

        在Itr中有一个将modCount的值赋值给expectedModCount的操作,其中expectedModCount是itr中的成员变量,但是在ArrayList和Itr中都没有modCount的声明,那就只能是一种可能:modCount继承自父类。所以现在可以完善AbstractList<E>的一部分了

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>{
    protected transient int modCount = 0;
    //实际修改值最初值为0
}

好了,到这里就破案了,最开始的时候expectedModCount和modCount的值都是0,但是在代码中我在迭代过程中通过list调用了一下add方法,但是在add方法中每add一次就会对modCount进行一次++,所以导致expectedModCount != modCount,最终抛出ConcurrentModificationException并发修改异常。

//ArrayList重写接口中的add方法
public boolean add(E e) {
    modCount++;
    //每次在集合中添加新的元素后实际修改值++
    add(e, elementData, size);
    return true;
}

既然现在找到了错误的源头,那就要想一个解决方案出来了,最终目的是查找是否有“world”这个元素,并向集合中添加元素。迭代器行不通就换一种方法进行迭代,例如for循环

for(int i = 0;i<list.size();++i){
        String s = list.get(i);//通过get获取元素
        if(s.equals("world")){
            list.add("javaee");
    }
}    

但是这里又有一个问题,通过get获取元素为什么就不会报错了?空口无凭还是来看看代码吧,前面已经分析过的部分就不在赘述了,直接拿过来搞里头:

public interface List<E> extends Collection<E> {
    boolean add(E e);
    E get(int index);
}
public class ArrayList<E> extends AbstractList<E>implements List<E>{

  //实现List接口中的get,add方法
  public E get(int index) {
     Objects.checkIndex(index, size);
     return elementData(index);
  }

  public boolean add(E e) {
      modCount++;
      add(e, elementData, size);
      return true;
   }
}

源码说明一切,可以看到ArrayList实现get方法时没有比较expectedModCount和modCount的操作,所以不管add中对modCount的值++多少次都没有影响。

下面再捋一下思路。

4. 总结

  1. 编译器抛出运行时异常(ConcurrentModificationException)
  2.  追溯异常出现的方法(Itr.next().checkForComodification())
  3.  跟进代码找出问题根源。
  4. 找出解决方案:采用for循环调用list.get()的方式遍历集合则可以避开checkForComodification()中的if (modCount != expectedModCount)比较,此时再调用add向集合添加元素即可。

        其中跟进代码思路如下:

  • 错误代码中通过list.iterator获取到元素迭代器,并通过循环调用next的方式实现遍历集合,当发现“world”时会执行add操作
  • ArrayList实现List中的add方法时加入了modCount++的操作,所以当向集合中添加元素后,modCount的值会发生变化
  • next方法调用了checkForComodification()方法,该方法中进行了if (modCount != expectedModCount)比较
  • 因为上一循环进行了add操作此时modCount值已经发生变化,再次进行比较时modCount != expectedModCount,所以抛出异常 

         大概就这些,欢迎指正。

这篇关于【Java笔记】以并发修改异常为例总结的出错解决办法的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!