CopyOnWriteArrayList详解

发表于5个月前(2013-10-08 11:54)阅读（
519） | 评论（
0）
8人收藏此文章, 我要收藏

赞0

CopyOnWriteArrayList
thread
CopyOnWriteArraySet

CopyOnWriteArrayList是ArrayList 的一个线程安全的变体，其中所有可变操作（add、set等等）都是通过对底层数组进行一次新的复制来实现的。

这一般需要很大的开销，但是当遍历操作的数量大大超过可变操作的数量时，这种方法可能比其他替代方法更 有效。在不能或不想进行同步遍历，但又需要从并发线程中排除冲突时，它也很有用。“快照”风格的迭代器方法在创建迭代器时使用了对数组状态的引用。此数组在迭代器的生存期内不会更改，因此不可能发生冲突，并且迭代器保证不会抛出ConcurrentModificationException。创建迭代器以后，迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操作（remove、set和add）不受支持。这些方法将抛出UnsupportedOperationException。允许使用所有元素，包括null。

内存一致性效果：当存在其他并发 collection 时，将对象放入CopyOnWriteArrayList之前的线程中的操作 happen-before 随后通过另一线程从CopyOnWriteArrayList中访问或移除该元素的操作。

这种情况一般在多线程操作时，一个线程对list进行修改。一个线程对list进行fore时会出现java.util.ConcurrentModificationException错误。

下面来看一个列子：两个线程一个线程fore一个线程修改list的值。

view source

print
?

01	package com.lucky.concurrent.list;

02

03	import java.util.ArrayList;

04	import java.util.List;

05	import java.util.concurrent.ExecutorService;

06	import java.util.concurrent.Executors;

07

08	public class CopyOnWriteArrayListDemo {

09

/**

10

* 读线程

11	* @author wangjie

12

*

13

*/

14	private static class ReadTaskimplements Runnable {

15	List<String> list;

16

17	public ReadTask(List<String> list) {

18	this.list = list;

19

}

20

21	public void run() {

22	for (String str : list) {

23	System.out.println(str);

24

}

25

}

26

}

27

/**

28

* 写线程

29	* @author wangjie

30

*

31

*/

32	private static class WriteTaskimplements Runnable {

33	List<String> list;

34	int index;

35

36	public WriteTask(List<String> list,int index) {

37	this.list = list;

38	this.index = index;

39

}

40

41	public void run() {

42	list.remove(index);

43	list.add(index,"write_" + index);

44

}

45

}

46

47	public void run() {

48	final int NUM =10;

49	List<String> list =new ArrayList<String>();

50	for (int i =0; i < NUM; i++) {

51	list.add("main_" + i);

52

}

53	ExecutorService executorService = Executors.newFixedThreadPool(NUM);

54	for (int i =0; i < NUM; i++) {

55	executorService.execute(new ReadTask(list));

56	executorService.execute(new WriteTask(list, i));

57

}

58	executorService.shutdown();

59

}

60

61	public static void main(String[] args) {

62	new CopyOnWriteArrayListDemo().run();

63

}

64

}

运行结果：





从结果中可以看出来。在多线程情况下报错。其原因就是多线程操作结果：那这个种方案不行我们就换个方案。用jdk自带的类CopyOnWriteArrayList来做容器。这个类和ArrayList最大的区别就是add(E) 的时候。容器会自动copy一份出来然后再尾部add(E)。看源码：

view source

print
?

01

/**

02	* Appends the specified element to the end of this list.

03

*

04	* @param e element to be appended to this list

05	* @return <tt>true</tt> (as specified by {@link Collection#add})

06

*/

07	public boolean add(E e) {

08	final ReentrantLock lock =this.lock;

09	lock.lock();

10

try {

11	Object[] elements = getArray();

12	int len = elements.length;

13	Object[] newElements = Arrays.copyOf(elements, len +1);

14	newElements[len] = e;

15	setArray(newElements);

16	return true;

17	} finally {

18	lock.unlock();

19

}

20

}

用到了Arrays.copyOf 方法。这样导致每次操作的都不是同一个引用。也就不会出现java.util.ConcurrentModificationException错误。
换了种方案看代码：

view source

print
?

1	// List<String> list =new ArrayList<String>();

2	CopyOnWriteArrayList<String> list =new CopyOnWriteArrayList<String>();

也就把容器list换成了 CopyOnWriteArrayList，其他的没变。线程里面的list不用改。因为 CopyOnWriteArrayList实现的也是list<E> 接口。看结果：




其结果没报错。
CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。
所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高性能，适用于以读为主的情况。