一个ConcurrentModificationException引发的思考，从遍历方法和集合本身解决遍历的线程安全问题

最新推荐文章于 2024-05-24 10:43:49 发布
最新推荐文章于 2024-05-24 10:43:49 发布
阅读量320 收藏
点赞数 3
文章标签： 线程安全 遍历集合

在讲如何线程安全地遍历List之前，先看看通常我们遍历一个List会采用哪些方式。

方式一：

for(int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

方式二：

Iterator iterator = list.iterator();
while(iterator.hasNext()) {
    System.out.println(iterator.next());
}

方式三：

for(Object item : list) {
    System.out.println(item);
}

方式四（Java 8）：

复制代码 
list.forEach(new Consumer<Object>() {
    @Override
    public void accept(Object item) {
        System.out.println(item);
    }
});
复制代码

方式五（Java 8 Lambda）：

list.forEach(item -> {
    System.out.println(item);
});

方式一的遍历方法对于RandomAccess接口的实现类（例如ArrayList）来说是一种性能很好的遍历方式。但是对于LinkedList这样的基于链表实现的List，通过list.get(i)获取元素的性能差。

方式二和方式三两种方式的本质是一样的，都是通过Iterator迭代器来实现的遍历，方式三是增强版的for循环，可以看作是方式二的简化形式。

方式四和方式五本质也是一样的，都是使用Java 8新增的forEach方法来遍历。方式五是方式四的一种简化形式，使用了Lambda表达式。

遍历List的同时操作List会发生什么？

先用非线程安全的ArrayList做个试验，用一个线程遍历List，遍历的同时另一个线程删除List中的一个元素，代码如下：

复制代码 
public static void main(String[] args) {
    // 初始化一个list，放入5个元素
    final List<Integer> list = new ArrayList<>();
    for(int i = 0; i < 5; i++) {
        list.add(i);
    }
    // 线程一：通过Iterator遍历List
    new Thread(new Runnable() {
        @Override
        public void run() {
            for(int item : list) {
                System.out.println("遍历元素：" + item);
                // 由于程序跑的太快，这里sleep了1秒来调慢程序的运行速度
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }).start();
    // 线程二：remove一个元素
    new Thread(new Runnable() {
        @Override
        public void run() {
            // 由于程序跑的太快，这里sleep了1秒来调慢程序的运行速度
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            list.remove(4);
            System.out.println("list.remove(4)");
        }
    }).start();
}
复制代码
运行结果： 
 遍历元素：0  
 遍历元素：1  
 list.remove(4)  

Exception in thread “Thread-0” java.util.ConcurrentModificationException

线程一在遍历到第二个元素时，线程二删除了一个元素，此时程序出现异常：ConcurrentModificationException。

试想如果一个老师正在点整个班级所有学生的人数（线程一遍历List），而校长（线程二）同时叫走几个学生，那么老师也肯定点不下去了。

所以我们会想到一个解决方案，那就是校长等待老师点完学生后，再叫走学生。即让线程二等待线程一的遍历完成后再进行remove元素。

使用线程安全的Vector

ArrayList是非线程安全的，Vector是线程安全的，那么把ArrayList换成Vector是不是就可以线程安全地遍历了？

将程序中的：

final List<Integer> list = new ArrayList<>();

改成：

final List<Integer> list = new Vector<>();

再运行一次试试，会发现结果和ArrayList一样会抛出ConcurrentModificationException异常。

为什么线程安全的Vector也不能线程安全地遍历呢？其实道理也很简单，看Vector源码可以发现它的很多方法都加上了synchronized来进行线程同步，例如add()、remove()、set()、get()，但是Vector内部的synchronized方法无法控制到遍历操作，所以即使是线程安全的Vector也无法做到线程安全地遍历。

如果想要线程安全地遍历Vector，需要我们去手动在遍历时给Vector加上synchronized锁，防止遍历的同时进行remove操作。相当于校长等待老师点完学生后，再叫走学生。代码如下：

复制代码 
public static void main(String[] args) {
    // 初始化一个list，放入5个元素
    final List<Integer> list = new Vector<>();
    for(int i = 0; i < 5; i++) {
        list.add(i);
    }
    // 线程一：通过Iterator遍历List
    new Thread(new Runnable() {
        @Override
        public void run() {
            // synchronized来锁住list，remove操作会在遍历完成释放锁后进行
            synchronized (list) {
                for(int item : list) {
                    System.out.println("遍历元素：" + item);
                    // 由于程序跑的太快，这里sleep了1秒来调慢程序的运行速度
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }).start();
    // 线程二：remove一个元素
    new Thread(new Runnable() {
        @Override
        public void run() {
            // 由于程序跑的太快，这里sleep了1秒来调慢程序的运行速度
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            list.remove(4);
            System.out.println("list.remove(4)");
        }
    }).start();
}
复制代码

运行结果：

遍历元素：0 

遍历元素：1 

遍历元素：2 

遍历元素：3 

遍历元素：4 

list.remove(4)

运行结果显示list.remove(4)的操作是等待遍历完成后再进行的。

CopyOnWriteArrayList

CopyOnWriteArrayList是java.util.concurrent包中的一个List的实现类。CopyOnWrite的意思是在写时拷贝，也就是如果需要对CopyOnWriteArrayList的内容进行改变，首先会拷贝一份新的List并且在新的List上进行修改，最后将原List的引用指向新的List。

使用CopyOnWriteArrayList可以线程安全地遍历，因为如果另外一个线程在遍历的时候修改List的话，实际上会拷贝出一个新的List上修改，而不影响当前正在被遍历的List。

相当于校长要想从班级喊走或者添加学生，需要把学生全部带到一个新的教室再进行操作，而老师则通过之前班级的快照在照片上清点学生。

复制代码 
public static void main(String[] args) {
    // 初始化一个list，放入5个元素
    final List<Integer> list = new CopyOnWriteArrayList<>();
    for(int i = 0; i < 5; i++) {
        list.add(i);
    }
    // 线程一：通过Iterator遍历List
    new Thread(new Runnable() {
        @Override
        public void run() {
            for(int item : list) {
                System.out.println("遍历元素：" + item);
                // 由于程序跑的太快，这里sleep了1秒来调慢程序的运行速度
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }).start();
    // 线程二：remove一个元素
    new Thread(new Runnable() {
        @Override
        public void run() {
            // 由于程序跑的太快，这里sleep了1秒来调慢程序的运行速度
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            list.remove(4);
            System.out.println("list.remove(4)");
        }
    }).start();
}
复制代码

运行结果：

遍历元素：0 

遍历元素：1 

list.remove(4) 

遍历元素：2 

遍历元素：3 

遍历元素：4

从上面的运行结果可以看出，虽然list.remove(4)已经移除了一个元素，但是遍历的结果还是存在这个元素。由此可以看出被遍历的和remove的是两个不同的List。

线程安全的List.forEach

List.forEach方法是Java 8新增的一个方法，主要目的还是用于让List来支持Java 8的新特性：Lambda表达式。

由于forEach方法是List的一个方法，所以不同于在List外遍历List，forEach方法相当于List自身遍历的方法，所以它可以自由控制是否线程安全。

我们看线程安全的Vector的forEach方法源码：

public synchronized void forEach(Consumer<? super E> action) {
    ...
}

可以看到Vector的forEach方法上加了synchronized来控制线程安全的遍历，也就是Vector的forEach方法可以线程安全地遍历。

下面可以测试一下：

复制代码 
public static void main(String[] args) {
    // 初始化一个list，放入5个元素
    final List<Integer> list = new Vector<>();
    for(int i = 0; i < 5; i++) {
        list.add(i);
    }
    // 线程一：通过Iterator遍历List
    new Thread(new Runnable() {
        @Override
        public void run() {
            list.forEach(item -> {
                System.out.println("遍历元素：" + item);
                // 由于程序跑的太快，这里sleep了1秒来调慢程序的运行速度
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }).start();
    // 线程二：remove一个元素
    new Thread(new Runnable() {
        @Override
        public void run() {
            // 由于程序跑的太快，这里sleep了1秒来调慢程序的运行速度
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            list.remove(4);
            System.out.println("list.remove(4)");
        }
    }).start();
}
复制代码

运行结果： 

遍历元素：0 

遍历元素：1 

遍历元素：2 

遍历元素：3 

遍历元素：4 

list.remove(4)

转载请注明原文地址：http://xxgblog.com/2016/04/02/traverse-list-thread-safe/

程序媛小小白
关注
如何线程安全地遍历List：Vector、CopyOnWriteArrayList
叉叉哥的BLOG
04-03 1万+
遍历List的多种方式在讲如何线程安全地遍历List之前，先看看通常我们遍历一个List会采用哪些方式。方式一：for(int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); }方式二：Iterator iterator = list.iterator(); while(iterator.hasNext()) {
java 多线程遍历list_如何线程安全地遍历List：Vector、CopyOnWriteArrayList
weixin_29095049的博客
02-16 1226
遍历List的多种方式在讲如何线程安全地遍历List之前，先看看通常我们遍历一个List会采用哪些方式。方式一：for(int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}方式二：Iterator iterator =list.iterator();while(iterator.hasNext()) {Syst...
vector 遍历_如何线程安全地遍历List
weixin_32821263的博客
01-21 369
遍历List的多种方式在讲如何线程安全地遍历List之前，先看看遍历一个List通常会采用哪些方式。方式一：123for(int i = 0; i < list.size(); i++) { System.out.println(list.get(i));}方式二：1234Iterator iterator = list.iterator();while(iterator....
如何线程安全地遍历List
ycllycll的博客
08-26 1244
一、ArrayList遍历问题 1.当只有一个线程迭代遍历ArrayList时：边遍历边修改List元素会出现ConcurrenMdifyedException 正确方法可以采用迭代器遍历迭代器修改元素 2.当多个线程访问ArrayList时（如：一个线程在遍历，一个线程在删除元素）： 想要线程安全的遍历可以采用： 1）CopyOnWriteArrayLis...
线程安全的遍历list
feng_0207的专栏
09-03 5823
遍历List的多种方式 在讲如何线程安全地遍历List之前，先看看通常我们遍历一个List会采用哪些方式。 方式一： for(int i = 0; i ) { System.out.println(list.get(i)); } 方式二： Iterator iterator = list.iterator(); while(iterator.hasNext
Android线程安全篇
pengxiaoping66的博客
08-28 201
Android线程安全篇。
java中循环遍历删除List和Set集合中元素的方法(推荐)
09-01
在Java编程中，遍历并删除集合（如List或Set）中的元素是一项常见的操作，但如果不正确地执行，可能会导致`ConcurrentModificationException`异常。这个异常通常在尝试修改正在迭代的集合时出现，因为Java的集合迭代...
java.util.ConcurrentModificationException 解决方法
09-01
`java.util.ConcurrentModificationException` 是一个在 Java 中常见的运行时异常，它通常发生在多线程环境中，当一个线程正在遍历一个集合（如 `ArrayList`, `HashMap` 等），而另一个线程同时尝试修改这个集合时。...
Java中List集合的遍历实例详解
08-26
Java中的List集合是一种常用的数据结构，它允许存储多个有序元素，并提供了各种操作这些元素的方法。在实际编程中，遍历List集合是常见的需求，用于访问和处理集合中的每个元素。本篇文章将详细介绍Java中List集合的...
android安全list
公众号shadow sock7
08-13 983
apk在线分析生成分析报告 https://www.hybrid-analysis.com 周圣韬 android http://blog.csdn.net/yzzst/article/category/1508367 IUnKnow ‘s Blog http://blog.leanote.com/cate/iunknow/b5c08ce63dba-2 关于Android逆向破解以及Andr
Java、Android多线程、线程安全、线程同步
03-27
NoHttp核心架构之多线程通信、线程安全、线程同步；synchronized锁，Lock锁；具体讲解请移步博客：http://blog.csdn.net/yanzhenjie1003/article/details/50992468
详解Java多线程处理List数据
08-26
主要介绍了Java多线程处理List数据，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Android基础学习（二十）—— 线程安全
123
12-09 1051
线程安全
JAVA中增强循环中用线程,Java for循环中是否有针对线程安全性的优化？
weixin_39645306的博客
02-26 311
I have a snippet of code that change a counter in two threads. It's not thread safe because I didn't put any atomic variable or lock in the code. It gives the right result as I expected if the code on...
线程安全的List都有什么？
qq_43985303的博客
04-24 1490
1> SynchronizedList 有较好的扩展性，可以将ArrayList ，LinkedList等都改成同步的，而Vector底层只有数组的结构。需要注意的是SynchronizedList的add等操作加了锁，但是iterator()方法没有加锁，如果使用迭代器遍历的时候需要在外面手动加锁。在写的时候加锁（ReentrantLock锁），读的时候不加锁，大大提升了读的速度。这个是最常听到的线程安全的List实现，但是已经不常用了。添加元素的时候，先加锁，再复制替换操作，再释放锁。
三种线程安全的List
最新发布
weixin_45131680的博客
05-24 2998
获取线程安全的List我们可以通过Vector、Collections.synchronizedList()方法和CopyOnWriteArrayList三种方式读多写少的情况下，推荐使用CopyOnWriteArrayList方式读少写多的情况下，推荐使用Collections.synchronizedList()的方式。
List容器线程安全，Queue
BigBug_500的博客
04-22 1424
区别： ArrayList底层是数组结构，查询快，增删慢，线程不安全，效率高。 LinkedList底层是双向链表数据结构，查询慢，增删快，线程不安全，效率高。 Vector底层是数组结构，查询快，增删慢，线程安全，效率低。 注意： 所谓的线程安全，不包括对这些集合类的复合操作；当第一个线程对复合操作时，第二个线程也进入未同步的复合操作，就会出现问题。但多线程单个去操作线程安全集合中的方...
线程安全的list之synchronizedList和CopyOnWriteArrayList
刘辉的专栏
06-20 1365
在上篇文章中我们已经介绍了其他的一些list集合，如ArrayList、linkedlist等。不清楚的可以看下上篇文章一文彻底了解List集合 但是向ArrayList这些会出现线程不安全的问题，我们该怎样解决呢？接下来就是要介绍我们线程安全的list集合synchronizedList和CopyOnWriteArrayList。 一、synchronizedList synchroniz...
遍历map集合删除key报java.util.ConcurrentModificationException 解决方法
10-29
解决这个问题的方法有两种： 1.使用迭代器的remove()方法删除元素，而不是使用Map的remove()方法。 2.在遍历Map集合时，使用ConcurrentHashMap代替HashMap，因为ConcurrentHashMap是线程安全的，可以在遍历时修改Map...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值