1.Copy-On-Write 是什么？
Copy-On-Write它是一种在计算机科学中常见的优化技术，主要应用于需要频繁读取但很少修改的数据结构上。 简单的说就是在计算机中就是当你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存，原来的内存就可以被回收掉了！ 既然是一种优化策略，我们看一段代码：
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
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/\*\*
\* @author 百里
\*/
public class BaiLiIteratorTest {
private static List<String\> list \= new ArrayList<>();
public static void main(String\[\] args) {
list.add("1");
list.add("2");
list.add("3");
Iterator<String\> iter \= list.iterator();
while (iter.hasNext()) {
System.err.println(iter.next());
}
System.err.println(Arrays.toString(list.toArray()));
}
}
|
上面的Demo在单线程下执行时没什么毛病，但是在多线程的环境中，就可能出异常，为什么呢？ 因为多线程迭代时如果有其他线程对这个集合list进行增减元素，会抛出java.util.ConcurrentModificationException的异常。 我们以增加元素为例子，运行下面这Demo：
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/\*\*
\* 并发迭代器问题示例代码
\* @author 百里
\*/
public class BaiLiConcurrentIteratorTest {
// 创建一个ArrayList对象
private static List<String\> list \= new ArrayList<>();
public static void main(String\[\] args) throws InterruptedException {
// 给ArrayList添加三个元素："1"、"2"和"3"
list.add("1");
list.add("2");
list.add("3");
// 开启线程池，提交10个线程用于在list尾部添加5个元素"121"
ExecutorService service \= Executors.newFixedThreadPool(10);
for (int i \= 0; i < 10; i++) {
service.execute(() -> {
for (int j \= 0; j < 5; j++) {
list.add("121");
}
});
}
// 使用Iterator迭代器遍历list并输出元素值
Iterator<String\> iter \= list.iterator();
for (int i \= 0; i < 10; i++) {
service.execute(() -> {
while (iter.hasNext()) {
System.err.println(iter.next());
|
这里暴露的问题是什么呢？
●多线程场景下迭代器遍历集合的读取操作和其他线程对集合进行写入操作会导致出现并发修改异常
解决方案：
●CopyOnWriteArrayList避免了多线程操作List线程不安全的问题
2.CopyOnWriteArrayList介绍
从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器，它们是CopyOnWriteArrayList和CopyOnWriteArraySet。CopyOnWrite容器非常有用，可以在非常多的并发场景中使用到。 CopyOnWriteArrayList原理： 在写操作(add、remove等)时，不直接对原数据进行修改，而是先将原数据复制一份，然后在新复制的数据上执行写操作，最后将原数据引用指向新数据。这样做的好处是读操作(get、iterator等)可以不加锁，因为读取的数据始终是不变的。 接下来我们就看下源码怎么实现的。
3.CopyOnWriteArrayList简单源码解读
add()方法源码：
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
|
/\*\*
\* Appends the specified element to the end of this list.
\*
\* @param e element to be appended to this list
\* @return {@code true} (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);//将引用指向新数组 1
return true;
} finally {
lock.unlock();//解锁啦
}
}
|
可以看到，CopyOnWriteArrayList中的写操作都需要先获取锁，然后再将当前的元素数组复制一份，并在新复制的元素数组上执行写操作，最后将数组引用指向新数组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
@SuppressWarnings("unchecked")
public E next() {
if (! hasNext()) //是否存在下一个元素
throw new NoSuchElementException(); //没有下一个元素，则会抛出NoSuchElementException异常
//snapshot是一个类成员变量，它是在创建迭代器时通过复制集合内容而获得的一个数组。
//cursor是另一个类成员变量，初始值为0，并在每次调用next()时自增1，表示当前返回元素的位置。
return (E) snapshot\[cursor++\];
}
|
而读操作不需要加锁，直接返回当前的元素数组即可。 这种写时复制的机制保证了读操作的线程安全性，但是会牺牲一些写操作的性能，因为每次修改都需要复制一份数组。因此，适合读远多于写的场合。 所以我们将多线程Demo中的ArrayList改为CopyOnWriteArrayList，执行就不会报错啦！
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/\*\*
\* 并发迭代器问题示例代码
\* @author 百里
\*/
public class BaiLiConcurrentIteratorTest {
// 创建一个ArrayList对象
private static CopyOnWriteArrayList<String\> list \= new CopyOnWriteArrayList<>();
public static void main(String\[\] args) throws InterruptedException {
// 给ArrayList添加三个元素："1"、"2"和"3"
list.add("1");
list.add("2");
list.add("3");
// 开启线程池，提交10个线程用于在list尾部添加5个元素"121"
ExecutorService service \= Executors.newFixedThreadPool(10);
for (int i \= 0; i < 10; i++) {
service.execute(() -> {
for (int j \= 0; j < 5; j++) {
list.add("121");
}
});
}
// 使用Iterator迭代器遍历list并输出元素值
Iterator<String\> iter \= list.iterator();
for (int i \= 0; i < 10; i++) {
service.execute(() -> {
while (iter.hasNext()) {
System.err.println(iter.next());
try {
|
4.CopyOnWriteArrayList优缺点
优点：
1线程安全。CopyOnWriteArrayList是线程安全的，由于写操作对原数据进行复制，因此写操作不会影响读操作，读操作可以不加锁，降低了并发冲突的概率。
2不会抛出ConcurrentModificationException异常。由于读操作遍历的是不变的数组副本，因此不会抛出ConcurrentModificationException异常。
缺点：
1写操作性能较低。由于每一次写操作都需要将元素复制一份，因此写操作的性能较低。
2内存占用增加。由于每次写操作都需要创建一个新的数组副本，因此内存占用会增加，特别是当集合中有大量数据时，内存占用较高。
3数据一致性问题。由于读操作遍历的是不变的数组副本，因此在对数组执行写操作期间，读操作可能读取到旧的数组数据，这就涉及到数据一致性问题。
5.CopyOnWriteArrayList使用场景
●读多写少。为什么？因为写的时候会复制新集合
●集合不大。为什么？因为写的时候会复制新集合
●实时性要求不高。为什么，因为有可能会读取到旧的集合数据
