面试官问： ArrayList 不是线程安全的，为什么？（看完这篇，以后反问面试官）

矫情吗；* 2023-09-25 16:49 84阅读 0赞

# 前言 #

金三银四 ？

也许，但是。

近日，又收到金三银四一线作战小队成员反馈的战况 ：

![ab47243e9f324920aa6594282d5b4581.png][]

我不管你从哪里看的面经，但是我不允许你看到我这篇文章之后，还不清楚这个面试问题。

![898c0e64b43a4a44b97dcbc98d479180.png][]

本篇内容预告：

ArrayList 是线程不安全的， 为什么 ？

① 结合代码去探一探所谓的不安全

② 我们弄清楚为什么不安全（结合源码以及我的个人讲述）

③ 不止步于为什么， 我们得知道怎么办（方案以及结合源码分析）

ps: 这篇文章 注定篇幅很长， 我会从非常非常小白0基础的角度去 很啰嗦地去讲一些内容。

距离上一次 这么臭长去讲 list集合相关的问题，还是21年的时候 ，个人认为也是很有学习价值的，大家也可以看看，但是注意就是 ，别看着看着回不来了，也是上万文字+图片+源码分析的文章:

[Java 移除List中的元素，这玩意讲究！][Java _List]

开整开整。

# 正文 #

##    看看它的不安全 以及 为什么不安全 ##

线程不安全 ，看看官腔怎么说：

> 线程不安全，是指不提供加锁机制保护,有可能出现多个线程先后更改数据造成所得到的数据是脏数据。

其实小白话就是 ：

> 多线程操作的时候 ，容易出现与我们预想不一致的结果。
> 
> 就比如说，你做好准备 接我两拳。
> 
> 本来你以为 我是打完一拳再打一拳。
> 
> 结果我直接一招双龙出海，两只手一起打你， 你顶得住么？（你根本防不住。）

开始结合代码一探究竟。

代码小栗子 ① ：

public static void main(String[] args) {
    
            int threadNum = 1;
    
            List<String> resultList = new ArrayList<>();
            for (int i = 0; i < threadNum; i++) {
                new Thread(() -> resultList.add(UUID.randomUUID().toString())).start();
            }
            System.out.println("我们最终得到的resultList大小："+resultList.size());
        }

代码简析：  
![0a7df1f84c404bdd8dc578286d92b15b.png][]

大家猜想结果是多少 ？

![8fcf8d4198524623973cd4337125e407.png][]

是 0 , 为什么不是 1 ？ 为什么会出现 0 ？ 不是往里面ADD 了一个元素么 ？

如果说你对这个 0 的结果很意外的话， 兄弟，你完了。

![aaca61c67cd5481aa461a761e9712c55.png][]

（吓你的，你本来要完了，还好你今天遇到了我）。

对这个 0 的结果很意外，代表你对线程方面的基础知识，可能还没了解。

**简析：**

因为for 里面 开了一个新的线程 new Thread ， 这个线程 负责往 list 里面 add 一个数据。  
但是 我们的打印 list.size 是 主线程 ， 也就是说，如果 在 新的线程 new Thread 没执行完add 方法， 主线程就执行打印的代码，

那么就是 0啊 。

所以就是说，我们 主线程 等一等，让 for循环里面的新的线程 new Thread 先插入数据。

public static void main(String[] args) throws InterruptedException {
    
            int threadNum = 1;
    
            List<String> resultList = new ArrayList<>();
            for (int i = 0; i < threadNum; i++) {
                new Thread(() -> resultList.add(UUID.randomUUID().toString())).start();
            }
            sleep(1000);
            System.out.println("我们最终得到的resultList大小："+resultList.size());
        }

![b8e9e6d836be4c468673cceb8d97cd0a.png][]

可以看到结果是1了 ：

![75cdd3208d66441bb4196b5adc473d8f.png][]

接下来我们把线程数改成10（另外主线程等5秒，给足够的时间让这个10个线程好好竞争一下） ，我们来看看 所谓的不安全 的ArrayList 能出现什么 ‘不安全’ ：

public static void main(String[] args) throws InterruptedException {
    
            int threadNum = 10;
    
            List<String> resultList = new ArrayList<>();
            for (int i = 0; i < threadNum; i++) {
                new Thread(()->{
                    resultList.add(UUID.randomUUID().toString().substring(0,8));
                    System.out.println(resultList);
                }).start();
            }
            sleep(5000);
            System.out.println("我们最终得到的resultList大小："+resultList.size());
        }

情况①：

正常运行的情况，可以看到 10个线程 不争不抢 ：  
  
![6e4b8029067b48bfb6fc7db65c34c143.png][]

显然这是不符合我们文章主题的，我们要看的是不安全。

情况②：

有竞争，但是线程们 很友好，所以也没出什么幺蛾子（仅仅对于往list塞数据这个动作来说）

![be45b8395a754a3f93ca1e91db6c09d3.png][]

情况③：

10个线程 显然还是 太少了， 而且我电脑机子又好， 终于出现 ‘不安全’情况了 ，非常难得。

![89675cb90de546dfa44d7ebfb37d54d6.png][]

多线程操作 ArrayList 导致出现 add赋值 出现 null 情景分析 ：

为什么会出现，先看看源码 ，

![e4040084bcd145aebffae56be87123e2.png][]

Object[] elementData  : 保存所有元素值的 数组

size :  elementData中存储的元素个数

再看看 add 函数的 源码 ：

![7ffe8cc8f0d24c6fbc5f562f15ed1181.png][]

![838b414e8f9943ea99fc25c66ac1b2ae.png][]

ensureExplicitCapacity （）函数：

>   
> 将当前的新元素加到列表后面，判断列表的 elementData 数组的大小是否满足。
> 
> 如果 size + 1 的这个需求长度大于 elementData 这个数组的长度，那么就要对这个数组进行扩容。

elementData\[size++\] = e ：

> e是传入的 值， 把这个值 赋值在 elementData数组的 size++ 位置 。

**大家看出来问题没？**

这两步没有和在一块操作。

也就说如果出现这个扩容的触发 和后面 赋值 并发情况 ，那么就有好戏看了。

ArrayList是基于数组实现，数组大小一旦确定就无法更改。

**ArrayList的扩容**： 将旧数组容器的元素拷贝到新大小的数组中(Arrays.copyOf函数)。

![a367aca6a4244dbda4db275461390a1b.png][]

而 通过new ArrayList<>()实例的对象初始化的大小是0，所以**第一次插入就肯定会触发扩容**。

这里又必须给大家推荐一篇好文章了：

（没错也是我写的，但是看到这，你别去看这篇，跟着我现在的思路继续分析 这个null值出现的情景，实在很感兴趣，自己一会再看）  
[Java ArrayList new出来，默认的容量到底是0还是10 ？][Java ArrayList new_0_10]

看看我们的截图， 第一个数据是 null 。

有趣。

第一个数据是 null （其实应该称为 执行扩容操作，并发导致出现null值 ）分析 ：

第一个线程A 插入数据时 属于首次add ，发现需要扩容， ok ， 线程A 去扩容去了。

然后 我们是多线程操作场景， for循环第二次，触发new第二个线程B来了，线程B去add的时候，

因为线程A第一次扩容可能并没完成,所以导致 线程B 扩容所拿到list的elementDate是旧的，并不是线程A第一次扩容后对象， 线程B 拿到的 **size还是 0 ，所以线程B 也认为自己是第一次add ，也需要扩容。**

![4122631b1ff7403481c7be980dde024f.png][]

幻想一下 A 、B 线程的并发 一起进入扩容场景：

那么**线程A** 是第一次add的时候，他知道他要去扩容， 他自己 扩容 完，自己整了个list的新elementDate ，然后 就开始赋值 elementDate\[size++\] = A的UUID值。

**在线程A这个操作的过程中，线程 B 在做什么？**

**线程 B**一开始 不巧也是以为要扩容，他拿着一个旧的 list的elementDate **也整了一个新的数组** ，

然后把 整个 list的 elementDate **引用指向** B线程自己弄出来的对象

this.elementData = B新构建的对象（这对象全部值为null）；

然后做什么？

![8094d5b2c9b14aa1aa469f0bb085cf14.png][]

然后 线程B 开始执行 elementDate\[size++\] = B的UUID值。

这里的好玩点是什么？

**线程A** 的值 赋值在 他创建出来的 elementDate 里面，然后触发**size++** 。

但是**线程 B** 呢， 把 this.elementData 指向了自己的新弄出来的， 所以 **A 的值 无情被抛弃**， 但是 **线程 B** 开始赋值的时候，

看看这个size在源码里的情况：

public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
    
        transient Object[] elementData;
    
       //这是大家共用的 size 
        private int size;
    }

size是大家共用的， size 被 **线程A** 加1了 ，所以就出现 **线程 B** 赋值的时候 执行 elementDate\[size++\] = B的UUID值，出来的结果是  
  
\[null , B的UUID值\]

**null 就是这么来的 ！ 能看到这的人，友情提示，你已经阅读了3500字。当然还没完事。**

情况④：

java.util.ConcurrentModificationException 并发冲突

![64089aa4ee154a3c966d3746b86b4cdc.png][]

直接定位报错函数：

![a2571dedc9b64b798d0e9cf1ce9bafbd.png][]

这个其实 之前分析过：

modCount是修改记录数，expectedModCount是期望修改记录数；  
初始化的时候 expectedModCount=modCount ；

ArrayList的add函数、remove函数 操作都有对modCount++操作，当expectedModCount和modCount值不相等， 那就会报并发错误了（其实这个不是仅仅是多线程的问题，是这个ArrayList 代码next函数的问题，更多细节可以有空看看 [Java 移除List中的元素，这玩意讲究！][Java _List]）。

那么到这 我们大概知道 这个 ArrayList的不安全 问题了， 说白了就是 2行代码没上锁操作。

##  ##

## **怎么办？ 怎么安全起来？** ##

最简单的方式， 也是面经上经常看到的 使用 Vector ：

List<String> resultList = new Vector<>();

看看vector怎么保证安全的：  
![a5fbe6f415a744499c677ad3050a0b92.png][]

其次 是 使用 Collections里面的synchronizedList ：

List<String> resultList =Collections.synchronizedList(new ArrayList<>());

看看synchronizedList 怎么保证安全的：

![781804804a7543b28008e6d0560596fa.png][]

还有可以使用 CopyOnWriteArrayList ：

List<String> resultList  = new CopyOnWriteArrayList();

看看CopyOnWriteArrayList 怎么保证安全的：

![230f06720bb54c3aa3bd1dcda0477eb7.png][]

ps:  
CopyOnWriteArrayList 的set 也是上锁  
![1705e3b528e64c0fbd44a112c50387fd.png][]

但是get 没有， 也就是说，get可能在多线程场景使用，拿到的是旧数据是可能的（也就是当前能读到的list里面的数据）  
![ec967deb34d44286b38afdbd2bf99562.png][]

那么就CopyOnWriteArrayList的 set\\add\\get 函数，你能预料到它的不好点么？

1.set add 都选择使用了Arrays.copyOf复制操作

![9469528d5e7446c89df0b699bc4f6e37.png][]![e0d4cedafce44853812caa092e62f2cf.png][]

所以存在 内存占用以及耗时问题，当数组元素越来越多的时候。

2. get 多线程过程读取数据不是实时，那就可能出现 数据不一致问题，但是最终数据是一致的（读多写少就很合适）。

好了，该篇就到这吧。

[ab47243e9f324920aa6594282d5b4581.png]: https://img-blog.csdnimg.cn/ab47243e9f324920aa6594282d5b4581.png
[898c0e64b43a4a44b97dcbc98d479180.png]: https://img-blog.csdnimg.cn/898c0e64b43a4a44b97dcbc98d479180.png
[Java _List]: https://blog.csdn.net/qq_35387940/article/details/112505679
[0a7df1f84c404bdd8dc578286d92b15b.png]: https://img-blog.csdnimg.cn/0a7df1f84c404bdd8dc578286d92b15b.png
[8fcf8d4198524623973cd4337125e407.png]: https://img-blog.csdnimg.cn/8fcf8d4198524623973cd4337125e407.png
[aaca61c67cd5481aa461a761e9712c55.png]: https://img-blog.csdnimg.cn/aaca61c67cd5481aa461a761e9712c55.png
[b8e9e6d836be4c468673cceb8d97cd0a.png]: https://img-blog.csdnimg.cn/b8e9e6d836be4c468673cceb8d97cd0a.png
[75cdd3208d66441bb4196b5adc473d8f.png]: https://img-blog.csdnimg.cn/75cdd3208d66441bb4196b5adc473d8f.png
[6e4b8029067b48bfb6fc7db65c34c143.png]: https://img-blog.csdnimg.cn/6e4b8029067b48bfb6fc7db65c34c143.png
[be45b8395a754a3f93ca1e91db6c09d3.png]: https://img-blog.csdnimg.cn/be45b8395a754a3f93ca1e91db6c09d3.png
[89675cb90de546dfa44d7ebfb37d54d6.png]: https://img-blog.csdnimg.cn/89675cb90de546dfa44d7ebfb37d54d6.png
[e4040084bcd145aebffae56be87123e2.png]: https://img-blog.csdnimg.cn/e4040084bcd145aebffae56be87123e2.png
[7ffe8cc8f0d24c6fbc5f562f15ed1181.png]: https://img-blog.csdnimg.cn/7ffe8cc8f0d24c6fbc5f562f15ed1181.png
[838b414e8f9943ea99fc25c66ac1b2ae.png]: https://img-blog.csdnimg.cn/838b414e8f9943ea99fc25c66ac1b2ae.png
[a367aca6a4244dbda4db275461390a1b.png]: https://img-blog.csdnimg.cn/a367aca6a4244dbda4db275461390a1b.png
[Java ArrayList new_0_10]: https://blog.csdn.net/qq_35387940/article/details/123050667
[4122631b1ff7403481c7be980dde024f.png]: https://img-blog.csdnimg.cn/4122631b1ff7403481c7be980dde024f.png
[8094d5b2c9b14aa1aa469f0bb085cf14.png]: https://img-blog.csdnimg.cn/8094d5b2c9b14aa1aa469f0bb085cf14.png
[64089aa4ee154a3c966d3746b86b4cdc.png]: https://img-blog.csdnimg.cn/64089aa4ee154a3c966d3746b86b4cdc.png
[a2571dedc9b64b798d0e9cf1ce9bafbd.png]: https://img-blog.csdnimg.cn/a2571dedc9b64b798d0e9cf1ce9bafbd.png
[a5fbe6f415a744499c677ad3050a0b92.png]: https://img-blog.csdnimg.cn/a5fbe6f415a744499c677ad3050a0b92.png
[781804804a7543b28008e6d0560596fa.png]: https://img-blog.csdnimg.cn/781804804a7543b28008e6d0560596fa.png
[230f06720bb54c3aa3bd1dcda0477eb7.png]: https://img-blog.csdnimg.cn/230f06720bb54c3aa3bd1dcda0477eb7.png
[1705e3b528e64c0fbd44a112c50387fd.png]: https://img-blog.csdnimg.cn/1705e3b528e64c0fbd44a112c50387fd.png
[ec967deb34d44286b38afdbd2bf99562.png]: https://img-blog.csdnimg.cn/ec967deb34d44286b38afdbd2bf99562.png
[9469528d5e7446c89df0b699bc4f6e37.png]: https://img-blog.csdnimg.cn/9469528d5e7446c89df0b699bc4f6e37.png
[e0d4cedafce44853812caa092e62f2cf.png]: https://img-blog.csdnimg.cn/e0d4cedafce44853812caa092e62f2cf.png