Java基础-并发编程-List与并发包List
集合ArrayList操作并发冲突
ArrayList线程不安全实例
public static void main(String[] args) {
testArrayListAdd();
}
private static void testArrayListAdd() {
List<Integer> arrayList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
arrayList.add(RandomUtil.randomInt());
System.out.println(arrayList.toString());
}).start();
}
}
打印结果:
Exception in thread "Thread-8" Exception in thread "Thread-2" java.util.ConcurrentModificationException
...
ArrayList线程不安全原因
导致产生ConcurrentModificationException异常原因:ArrayList里使用modCount++,++运算在多线程中是不安全的。
modCount主要是为了防止在迭代过程中某些原因改变了原集合,导致出现不可预料的情况,从而抛出并发修改异常,是ArrayList里的Fail-Fast机制。
//add方法modCount操作源码
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
ArrayList线程不安全解决方案
ArrayList线程不安全解决方案:
- new Vector<>()
- Collections.synchronizedList(new ArrayList<>())
- new CopyOnWriteArrayList<>()
package com.study.thread.conllection;
import cn.hutool.core.util.RandomUtil;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;
public class CopyOnWriteArrayListTest {
public static void main(String[] args) {
testArrayListAdd();
// testArrayListAdd2();
// testCopyOnWriteArrayListAdd();
// testVectorAdd();
}
private static void testArrayListAdd() {
List<Integer> arrayList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
arrayList.add(RandomUtil.randomInt());
System.out.println(arrayList.toString());
}).start();
}
}
private static void testCopyOnWriteArrayListAdd() {
CopyOnWriteArrayList<Integer> copyOnwirteArrayList = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
copyOnwirteArrayList.add(RandomUtil.randomInt());
System.out.println(copyOnwirteArrayList.toString());
}).start();
}
}
private static void testArrayListAdd2() {
List<Integer> arrayList = Collections.synchronizedList(new ArrayList<>());
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
arrayList.add(RandomUtil.randomInt());
System.out.println(arrayList.toString());
}).start();
}
}
private static void testVectorAdd() {
List<Integer> vector = new Vector<>();
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
vector.add(RandomUtil.randomInt());
System.out.println(vector.toString());
}).start();
}
}
}
CopyOnWriteArrayList如何做到线程安全的
CopyOnWriteArrayList使用了一种叫 写时复制 的方法,当有新元素添加到CopyOnWriteArrayList时,先从原有的数组中拷贝一份出来,然后在新的数组做写操作,写完之后,再将原来的数组引用指向到新数组。
当有新元素加入的时候,如下图,创建新数组,并往新数组中加入一个新元素,这个时候,array这个引用仍然是指向原数组的。
当元素在新数组添加成功后,将array这个引用指向新数组。
CopyOnWriteArrayList的整个add操作都是在锁的保护下进行的。
这样做是为了避免在多线程并发add的时候,复制出多个副本出来,把数据搞乱了,导致最终的数组数据不是我们期望的。
CopyOnWriteArrayList的add操作的源代码如下:
public boolean add(E e) {
//1、先加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
//2、拷贝数组
Object[] newElements = Arrays.copyOf(elements, len + 1);
//3、将元素加入到新数组中
newElements[len] = e;
//4、将array引用指向到新数组
setArray(newElements);
return true;
} finally {
//5、解锁
lock.unlock();
}
}
由于所有的写操作都是在新数组进行的,这个时候如果有线程并发的写,则通过锁来控制,如果有线程并发的读,则分几种情况:
1、如果写操作未完成,那么直接读取原数组的数据;
2、如果写操作完成,但是引用还未指向新数组,那么也是读取原数组数据;
3、如果写操作完成,并且引用已经指向了新的数组,那么直接从新数组中读取数据。
可见,CopyOnWriteArrayList的读操作是可以不用加锁的。
CopyOnWriteArrayList的使用场景
通过上面的分析,CopyOnWriteArrayList 有几个缺点:
1、由于写操作的时候,需要拷贝数组,会消耗内存,如果原数组的内容比较多的情况下,可能导致young gc或者full gc
2、不能用于实时读的场景,像拷贝数组、新增元素都需要时间,所以调用一个set操作后,读取到数据可能还是旧的,虽然CopyOnWriteArrayList 能做到最终一致性,但是还是没法满足实时性要求;
CopyOnWriteArrayList 合适读多写少的场景,不过这类慎用,在使用时需确认操作的元素大小极限值。
CopyOnWriteArrayList 中的数据如果很多的话,每次add/set都要重新复制数组,代价就会很高。在高性能的互联网应用中,这种操作极易引起故障。
CopyOnWriteArrayList 和 Vector 的区别
- Vector是【绝对】线程安全的,CopyOnWriteArrayList只能保证读线程会读到【已完成】的写结果,但无法像Vector一样实现读操作的【等待写操作完成后再读最新值】的能力
- CopyOnWriteArrayList读性能远高于Vector,并发线程越多优势越明显
- CopyOnWriteArrayList占用更多的内存空间
- Vector 不能避免 ConcurrentModificationException 问题,而 CopyOnWriteArrayList 不存在这个问题。