线程安全的List, 从Vector 到 SynchronizedList 到 CopyOnWriteArrayList

106 阅读 0 评论 70 点赞

我是靠谱客的博主典雅小天鹅，这篇文章主要介绍线程安全的List, 从Vector 到 SynchronizedList 到 CopyOnWriteArrayList，现在分享给大家，希望可以做个参考。

文章目录

大部分人会脱口而出：用Vector，这样只会让面试官鄙视！除了Vector，你还会别的吗？

你至少还得说得上这种：

java.util.Collections.SynchronizedList

它能把所有 List 接口的实现类转换成线程安全的List，比 Vector 有更好的扩展性和兼容性，Syfinal List list;

复制代码

1
2
3
4
5
SynchronizedList(List<E> list) {
super(list);
this.list = list;
}nchronizedList的构造方法如下：

SynchronizedList的部分方法源码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
public E get(int index) {
synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}

很可惜，它所有方法都是带同步对象锁的，和 Vector 一样，它不是性能最优的。即使你能说到这里，面试官还会继续往下追问，比如在读多写少的情况，SynchronizedList这种集合性能非常差，还有没有更合适的方案？
绍两个并发包里面的并发集合类：

java.util.concurrent.CopyOnWriteArrayList
java.util.concurrent.CopyOnWriteArraySet

首先我讲一下什么是Copy-On-Write，顾名思义，在计算机中就是当你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存，原来的内存就可以被回收掉嘛！
网上兄弟们说了，这是一种用于程序设计中的优化策略，是一种延时懒惰策略。都说优化优化，那么到底优化了哪些问题呢？

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class IteratorTest {
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();
//我当前正在迭代集合（这里模拟并发中读取某一list的场景）
while (iter.hasNext()) {
System.err.println(iter.next());
}
System.err.println(Arrays.toString(list.toArray()));
}
}

上面的程序片段在单线程下执行时没什么毛病的，但到了多线程的环境中，可能就GG了！为什么呢？因为多线程环境中，你在迭代的时候是不允许有其他线程对这个集合list进行添加元素的，看下面这段代码，你会发现抛出java.util.ConcurrentModificationException的异常。

复制代码

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
public class IteratorTest {
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();
// 存放10个线程的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
// 执行10个任务(我当前正在迭代集合（这里模拟并发中读取某一list的场景）)
for (int i = 0; i < 10; i++) {
service.execute(new Runnable() {
@Override
public void run() {
while (iter.hasNext()) {
System.err.println(iter.next());
}
}
});
}
// 执行10个任务
for (int i = 0; i < 10; i++) {
service.execute(new Runnable() {
@Override
public void run() {
list.add("121");// 添加数据
}
});
}
System.err.println(Arrays.toString(list.toArray()));
}
}

1、这里的迭代表示我当前正在读取某种集合中的数据,属于读操作；
2、线程则模拟当前程序处于多线程环境中，有其他线程正在修改该数据
这里暴露的问题是什么呢？

1、多线程会对迭代集合产生影响，影响读操作

CopyOnWriteArrayList简单源码解读

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
* 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();//解锁啦
}
}

恍然大悟，小样，原来add()在添加集合的时候加上了锁，保证了同步，避免了多线程写的时候会Copy出N个副本出来。(想想，你在遍历一个10个元素的集合，每遍历一次有1人调用add方法，你说当你遍历10次，这add方法是不是得被调用10次呢？是不是得copy出10分新集合呢？万一这个集合非常大呢？)
那么？你还要问？CopyOnWriteArrayList是怎么解决线程安全问题的？答案就是----写时复制，加锁
还要问？那么有没有这么一种情况，当一个线程刚好调用完add()方法，也就是刚好执行到上面1处的代码，也就是刚好将引用指向心数组，而此时有线程正在遍历呢？会不会报错呢？（答案是不会的，因为你正在遍历的集合是旧的，这就有点难受啦，哈哈~）
缺点：