标签：copyonwritearraylist arraylist
CopyOnWriteArrayList是ArrayList的一个线程安全的变体，其中所有可变操作（add、set等等）都是通过对底层数组进行一次新的复制来实现的。
这一般需要很大的开销，但是当遍历操作的数量大大超过可变操作的数量时，这种方法可能比其他替代方法更 有效。在不能或不想进行同步遍历，但又需要从并发线程中排除冲突时，它也很有用。“快照”风格的迭代器方法在创建迭代器时使用了对数组状态的引用。此数组在迭代器的生存期内不会更改，因此不可能发生冲突，并且迭代器保证不会抛出ConcurrentModificationException。创建迭代器以后，迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操作（remove、set和add）不受支持。这些方法将抛出UnsupportedOperationException。
允许使用所有元素，包括null。
内存一致性效果：当存在其他并发 collection 时，将对象放入CopyOnWriteArrayList之前的线程中的操作 happen-before随后通过另一线程从CopyOnWriteArrayList中访问或移除该元素的操作。
这种情况一般在多线程操作时，一个线程对list进行修改。一个线程对list进行for时会出现java.util.ConcurrentModificationException错误。
下面来看一个列子：两个线程一个线程for一个线程修改list的值。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
package
com.lucky.concurrent.list; import
java.util.ArrayList; import
java.util.List; import
java.util.concurrent.ExecutorService; import
java.util.concurrent.Executors; public
class CopyOnWriteArrayListDemo {
/**
* 读线程
*
*
*/ private
static class
ReadTask implements
Runnable { List<String> list;
public
ReadTask(List<String> list) { this.list = list;
}
public
void run() { for
(String str : list) { System.out.println(str);
}
}
}
/**
* 写线程
*
*
*/ private
static class
WriteTask implements
Runnable { List<String> list;
int
index; public
WriteTask(List<String> list, int
index) { this.list = list;
this.index = index;
}
public
void run() { list.remove(index);
list.add(index,
"write_" + index);
}
}
public
void run() { final
int NUM = 10;
List<String> list =
new ArrayList<String>();
for
(int
i = 0; i < NUM; i++) {
list.add("main_"
+ i); }
ExecutorService executorService = Executors.newFixedThreadPool(NUM);
for
(int
i = 0; i < NUM; i++) {
executorService.execute(new
ReadTask(list)); executorService.execute(new
WriteTask(list, i)); }
executorService.shutdown();
}
public
static void
main(String[] args) { new
CopyOnWriteArrayListDemo().run(); }
} |
从结果中可以看出来。在多线程情况下报错。其原因就是多线程操作结果：那这个种方案不行我们就换个方案。用jdk自带的类CopyOnWriteArrayList来做容器。这个类和ArrayList最大的区别就是add(E) 的时候。容器会自动copy一份出来然后再尾部add(E)。看源码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/ public
boolean add(E e) {
final
ReentrantLock lock = this.lock;
lock.lock();
try
{ Object[] elements = getArray();
int
len = elements.length; Object[] newElements = Arrays.copyOf(elements, len +
1); newElements[len] = e;
setArray(newElements);
return
true; }
finally {
lock.unlock();
}
} |
用到了Arrays.copyOf 方法。这样导致每次操作的都不是同一个引用。也就不会出现java.util.ConcurrentModificationException错误。
换了种方案看代码：
|
1
2
|
// List<String> list = new ArrayList<String>();
CopyOnWriteArrayList<String> list = new
CopyOnWriteArrayList<String>(); |
其结果没报错。
CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。
优点：
CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，
保证读的高性能，适用于以读为主的情况。
缺点：
CopyOnWriteArrayList采用“写入时复制”策略，对容器的写操作将导致的容器中基本数组的复制，性能开销较大。所以在有写操作的情况下，CopyOnWriteArrayList性能不佳，而且如果容器容量较大的话容易造成溢出。
标签：copyonwritearraylist arraylist
原文地址：http://blog.csdn.net/lhl6688/article/details/43968583
