集合不安全之 ArrayList及其三种解决方案【CopyOnWriteArrayList 、synchronizedList、Vector 】
文章目录
一、前言
二、为什么线程不安全
三、解决方案一CopyOnWriteArrayList （推荐，读多写少场景）
四、Collections.synchronizedList（加锁）
五、Vector （加锁）
六、synchronizedList、Vector都是加锁，区别？
七、总结
一、前言
我们在高并发的场景下，难免会出现并发问题，特别是ArrayList这种常用的集合。这种事情还是要考虑的，今天就带大家一起看一下ArrayList为什么不安全？有哪些解决方案呢？
二、为什么线程不安全
1. 出错演示
import java.util.ArrayList; import java.util.List; import java.util.UUID; public class ArrayListDemo { public static void main(String[] args) { List<String> list = new ArrayList<>(); for (int x = 0; x < 20; x++) { new Thread(() -> { list.add(UUID.randomUUID().toString()); System.out.println(list); },String.valueOf(x)).start(); } } }
2. ConcurrentModificationException（并发修改异常）
3. 原因
ArrayList 是线程不安全的，多个线程同时操作会出异常 ，并发修改出现异常，导致modCount和操作次数不一致。
//ArrayList源码 private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }
三、解决方案一CopyOnWriteArrayList （推荐，读多写少场景）
1. 解决方案
import java.util.ArrayList; import java.util.List; import java.util.UUID; import java.util.concurrent.CopyOnWriteArrayList; public class ArrayListDemo { public static void main(String[] args) { List<String> list = new CopyOnWriteArrayList(); for (int x = 0; x < 20; x++) { new Thread(() -> { list.add(UUID.randomUUID().toString()); System.out.println(list); },String.valueOf(x)).start(); } } }
2. 源码解读
/** * 写时复制 * 思想就是先拷贝出来，在拷贝集合的最后添加新元素，最后把集合在set进去 * 写的时候进行加锁，读没有限制 * 适用场景：读多写少 */ public boolean add(E e) { final ReentrantLock lock = this.lock; // 加可重入锁 lock.lock(); try { // 拷贝当前集合数组 Object[] elements = getArray(); // 获取当前集合数组长度 int len = elements.length; // 原集合数组空间+1，同时将原集合数组复制 Object[] newElements = Arrays.copyOf(elements, len + 1); // 把新增元素赋值到新集合数组中 newElements[len] = e; // 最后再把新集合数组设置到集合中 setArray(newElements); return true; } finally { // 释放锁 lock.unlock(); } }
四、Collections.synchronizedList（加锁）
1. 解决方案
public class ArrayListDemo { public static void main(String[] args) { List<String> list = Collections.synchronizedList(new ArrayList<>()); for (int x = 0; x < 20; x++) { new Thread(() -> { list.add(UUID.randomUUID().toString()); System.out.println(list); },String.valueOf(x)).start(); } } }
2. 源码解读（加锁同步代码块）
public boolean add(E e) { synchronized (mutex) {return c.add(e);} }
五、Vector （加锁）
1. 解决方案
public class ArrayListDemo { public static void main(String[] args) { List<String> list = new Vector<>(); for (int x = 0; x < 20; x++) { new Thread(() -> { list.add(UUID.randomUUID().toString()); System.out.println(list); },String.valueOf(x)).start(); } } }
2. 源码解读（加锁同步方法）
public synchronized boolean add(E e) { modCount++; ensureCapacityHelper(elementCount + 1); elementData[elementCount++] = e; return true; }
六、synchronizedList、Vector都是加锁，区别？
同步代码块和同步方法的区别：
因为SynchronizedList只是使用同步代码块包裹了ArrayList的方法，而ArrayList和Vector中同名方法的方法体内容并无太大差异，所以在锁定范围和锁的作用域上两者并无区别。 在锁定的对象区别上，SynchronizedList的同步代码块锁定的是mutex对象，Vector锁定的是this对象
而其实mutex对象就是SynchronizedList有一个构造函数可以传入一个Object类型对象，如果在调用的时候显示的传入一个对象，那么锁定的就是用户传入的对象。如果没有指定，那么锁定的也是this对象。结果就是SynchronizedList可以指定锁定的对象
基于我们将ArrayList转成SynchronizedList。那么如果我们想把LinkedList变成线程安全的，或者说我想要方便在中间插入和删除的同步的链表，那么我可以将已有的LinkedList直接转成SynchronizedList，而不用改变他的底层数据结构。而这一点是Vector无法做到的，因为他的底层结构就是使用数组实现的，这个是无法更改的
SynchronizedList和Vector区别：
1.SynchronizedList有很好的扩展和兼容功能。他可以将所有的List的子类转成线程安全的类
2.使用SynchronizedList的时候，进行遍历时要手动进行同步处理
3.SynchronizedList可以指定锁定的对象
答案来源
七、总结
这样我们就对为什么不安全和三种解决方案进行测试和源码的初探，小编也是菜鸟，主要是看了尚硅谷阳哥的课。自己记录一遍，以后看！！喜欢的收藏一波，收藏从未停止，行动从未开始！！
