转载

如何线程安全地遍历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);
});

首先，方式一的遍历方法是一种 非常不建议使用 的方式，特别是对于LinkedList。LinkedList是基于链表实现的，通过 list.get(i) 获取元素的性能差，所以方式一是性能很差的一种遍历方式。本文接下来的内容不再讨论这种方式的遍历。

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

方式四和方式五本质也是一样的，都是使用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();
}