怎样线程安全地遍历List：Vector、CopyOnWriteArrayList

遍历List的多种方式

在讲怎样线程安全地遍历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也不能线程安全地遍历呢？事实上道理也非常easy，看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/

时间： 2024-10-01 03:40:59

怎样线程安全地遍历List：Vector、CopyOnWriteArrayList的相关文章

如何线程安全地遍历List：Vector、CopyOnWriteArrayList

遍历List的多种方式 在讲如何线程安全地遍历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

用快照对进程、模块、线程进行遍历（代码段）

前置知识:windows提供了一组快照API,使用前需要包含TlHelp32.h头文件. 1.能够给当前系统中的所有进程拍一个快照,能够获取所有进程的一些基本信息: 2.能够给当前系统中的线程拍一个快照: 3.能够给某一个进程拍模块快照: 4.能够给某一个进程拍堆快照. 一:遍历进程 int _tmain(int argc, _TCHAR* argv[]) { HANDLE hProcessSnap; // 进程快照句柄 HANDLE hProcess; // 进程句柄 PROCESSENTRY

线程安全地获取插入mysql的条目的id

在往mysql中插入条目时有时会希望能得到该插入条目的id,一种方式是再执行一个select语句条件为max(id)来获取,但这种形式在并发环境里并不是线程安全的,因为在你完成插入到再执行一个select获取最大id之间可能已经有另一个条目被插入. 一种线程安全的解决方式是采用select LAST_INSERT_ID()这个语句,它返回本次链接(每个数据库链接由一个线程承担)中第一次插入的条目的id eg. (1).在连接1中向A表插入一条记录,A表包含一个auto_increment类型的i

线程-转

哪里摘的不记得.偶然发现在记事本里存着.没法注明作者了,抱歉. 40个问题汇总 1.多线程有什么用? 一个可能在很多人看来很扯淡的一个问题:我会用多线程就好了,还管它有什么用?在我看来,这个回答更扯淡.所谓"知其然知其所以然","会用"只是"知其然","为什么用"才是"知其所以然",只有达到"知其然知其所以然"的程度才可以说是把一个知识点运用自如.OK,下面说说我对这个问题的看法: (1

Java集合容器面试题

什么是集合 集合框架:用于存储数据的容器. 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构. 任何集合框架都包含三大块内容:对外的接口.接口的实现和对集合运算的算法. 接口:表示集合的抽象数据类型.接口允许我们操作集合时不必关注具体实现,从而达到"多 态".在面向对象编程语言中,接口通常用来形成规范. 实现:集合接口的具体实现,是重用性很高的数据结构. 算法:在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算的方法,例如查 找.排序等.这些算法通常是多态的,因为相

40个多线程问题总结

前言 多线程分类中写了21篇多线程的文章,21篇文章的内容很多,个人认为,学习,内容越多.越杂的知识,越需要进行深刻的总结,这样才能记忆深刻,将知识变成自己的.这篇文章主要是对多线程的问题进行总结的,因此罗列了40个多线程的问题. 这些多线程的问题,有些来源于各大网站.有些来源于自己的思考.可能有些问题网上有.可能有些问题对应的答案也有.也可能有些各位网友也都看过,但是本文写作的重心就是所有的问题都会按照自己的理解回答一遍,不会去看网上的答案,因此可能有些问题讲的不对,能指正的希望大家不吝指教.

40个Java多线程问题总结

前言 Java多线程分类中写了21篇多线程的文章,21篇文章的内容很多,个人认为,学习,内容越多.越杂的知识,越需要进行深刻的总结,这样才能记忆深刻,将知识变成自己的.这篇文章主要是对多线程的问题进行总结的,因此罗列了40个多线程的问题. 这些多线程的问题,有些来源于各大网站.有些来源于自己的思考.可能有些问题网上有.可能有些问题对应的答案也有.也可能有些各位网友也都看过,但是本文写作的重心就是所有的问题都会按照自己的理解回答一遍,不会去看网上的答案,因此可能有些问题讲的不对,能指正的希望大家不

Java多线程问题总结

前言 Java多线程分类中写了21篇多线程的文章,21篇文章的内容很多,个人认为,学习,内容越多.越杂的知识,越需要进行深刻的总结,这样才能记忆深刻,将知识变成自己的.这篇文章主要是对多线程的问题进行总结的,因此罗列了40个多线程的问题. 这些多线程的问题,有些来源于各大网站.有些来源于自己的思考.可能有些问题网上有.可能有些问题对应的答案也有.也可能有些各位网友也都看过,但是本文写作的重心就是所有的问题都会按照自己的理解回答一遍,不会去看网上的答案,因此可能有些问题讲的不对,能指正的希望大家不

【转】40个Java多线程问题总结

文章转自 五月的仓颉 http://www.cnblogs.com/xrq730/p/5060921.html 前言 Java多线程分类中写了21篇多线程的文章,21篇文章的内容很多,个人认为,学习,内容越多.越杂的知识,越需要进行深刻的总结,这样才能记忆深刻,将知识变成自己的.这篇文章主要是对多线程的问题进行总结的,因此罗列了40个多线程的问题. 这些多线程的问题,有些来源于各大网站.有些来源于自己的思考.可能有些问题网上有.可能有些问题对应的答案也有.也可能有些各位网友也都看过,但是本文写作