ArrayList--线程不安全的原因/保证线程安全的方法--方案/实例

水深无声 2022-09-17 01:57 113阅读 0赞

原文网址：[ArrayList--线程不安全的原因/保证线程安全的方法--方案/实例\_IT利刃出鞘的博客-CSDN博客][ArrayList--_--_IT_-CSDN]

# 简介 #

本文介绍Java中的ArrayList如何进行线程安全的操作、为什么ArrayList不是线程安全的、LinkedList如何进行线程安全的操作。

这几个问题也是Java后端面试中经常问到的问题。

# ArrayList线程安全 #

## 线程安全的操作方法 ##

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 示例 </td> 
 <td> 原理 </td> 
 </tr> 
 <tr> 
 <td> Vector </td> 
 <td> List list = new ArrayList();替换为List arrayList = new Vector&lt;&gt;(); </td> 
 <td> 使用了synchronized关键字 </td> 
 </tr> 
 <tr> 
 <td> Collections.synchronizedList(List) </td> 
 <td> List&lt;String&gt; list = Collections.synchronizedList(new ArrayList&lt;String&gt;()); 操作外部list，实际上修改的是原来list的数据。 </td> 
 <td> Object mutex = new Object()。对此对象使用synchronized </td> 
 </tr> 
 <tr> 
 <td> JUC中的CopyOnWriteArrayList </td> 
 <td> CopyOnWriteArrayList&lt;String&gt; list= new CopyOnWriteArrayList&lt;String&gt;(); 适用于读多写少的并发场景。 </td> 
 <td> Write的时候总是要Copy（将原来array复制到新的array，修改后，将引用指向新数组）。任何可变的操作（add、set、remove等）都通过ReentrantLock 控制并发。 </td> 
 </tr> 
 </tbody> 
</table>

## **线程不安全（复现）** ##

**实例**

package org.example.a;
 
 import java.util.ArrayList;
 import java.util.List;
 
 class MyThread extends Thread{
 public void run(){
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 Demo.arrayList.add(Thread.currentThread().getName() + " " + System.currentTimeMillis());
 }
 }
 
 public class Demo{
 public static List arrayList = new ArrayList();
 public static void main(String[] args) {
 Thread[] threadArray = new Thread[1000];
 for(int i = 0;i < threadArray.length;i++){
 threadArray[i] = new MyThread();
 threadArray[i].start();
 }
 
 for(int i = 0;i < threadArray.length;i++){
 try {
 threadArray[i].join();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 for(int i = 0;i < arrayList.size(); i++){
 System.out.println(arrayList.get(i));
 }
 }
 }

**运行结果**

Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: 49
        at java.util.ArrayList.add(ArrayList.java:459)
        at org.example.a.MyThread.run(Demo.java:13)
    Thread-3 1590288167830
    Thread-7 1590288167834
    Thread-57 1590288167834
    ...
    null
    Thread-951 1590288168255
    Thread-254 1590288168255
    ...

总共有四种情况：

1.  正常输出
2.  输出值为null;
3.  数组越界异常;
4.  某些线程没有输出值;

## **线程不安全（原因分析）** ##

**ArrayList源码**

public boolean add(E e) {
 // 确保ArrayList的长度足够
 ensureCapacityInternal(size + 1); // Increments modCount!!
 // ArrayList加入
 elementData[size++] = e;
 return true;
 }
 
 private void ensureCapacityInternal(int minCapacity) {
 if (elementData == EMPTY_ELEMENTDATA) {
 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
 }
 ensureExplicitCapacity(minCapacity);
 }
 
 private void ensureExplicitCapacity(int minCapacity) {
 modCount++;
 
 // overflow-conscious code
 if (minCapacity - elementData.length > 0)
 grow(minCapacity);
 }
 
 // 如果超过界限 数组长度增长
 private void grow(int minCapacity) {
 // overflow-conscious code
 int oldCapacity = elementData.length;
 int newCapacity = oldCapacity + (oldCapacity >> 1);
 if (newCapacity - minCapacity < 0)
 newCapacity = minCapacity;
 if (newCapacity - MAX_ARRAY_SIZE > 0)
 newCapacity = hugeCapacity(minCapacity);
 // minCapacity is usually close to size, so this is a win:
 elementData = Arrays.copyOf(elementData, newCapacity);
 }

在上述过程中,会出问题的部分在于: 1. 增加元素 2. 扩充数组长度;

增加元素过程中较为容易出现问题的部分在于elementData\[size++\] = e;.赋值的过程可以分为两个步骤elementData\[size\] = e;size++;。我们分别使用两个线程来模拟插入过程.例如有两个线程,分别加入数字1与2.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95YW54bWwuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

运行的过程如下所示:

1.  线程1 赋值 element\[1\] = 1; 随后因为时间片用完而中断;
2.  线程2 赋值 element\[1\] = 2; 随后因为时间片用完中断;  
    此处导致了之前所说的一个问题(有的线程没有输出); 因为后续的线程将前面的线程的值覆盖了.
3.  线程1 自增 size++; (size=2)
4.  线程2 自增 size++; (size=3)  
    此处导致了某些值为null的问题.因为原size=1, 但是因为线程1与线程2都将值赋值给了element\[1\],导致了element\[2\]内没有值,被跳过了.指针index指向了3.所以,导致了某些情况下值为null的情况.

**数组越界情况**

我们将上方的线程运行图更新下进行演示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95YW54bWwuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1][]

前提条件: 当前size=2 数组长度为2.

1.  线程1 判断数组是否越界.因为size=2 长度为2,没有越界.将进行赋值操作.但是因为时间片问题导致了中断.
2.  线程2 判断数组是否越界.因为size=2 长度为2,没有越界.将进行赋值操作.但是因为时间片问题导致了中断.
3.  线程1 重新获取到主动权.上文判断了长度刚刚好够用.进行赋值操作element\[size\]=1,并且size++
4.  线程2 因为上文判断了数组没有越界.所以进行赋值操作.但是此时的size=3了.再执行element\[3\]=2. 导致了数组越界了.

由此处可以看出因为数组的当前指向size并未进行加锁的操作,导致了数组越界的情况出现。

# LinkedList线程安全 #

线程安全的操作方法

<table> 
 <tbody> 
 <tr> 
 <td>方法</td> 
 <td>示例</td> 
 <td>原理</td> 
 </tr> 
 <tr> 
 <td>Collections.synchronizedList(List)</td> 
 <td>public static List linkedList = Collections.synchronizedList(new LinkedList());</td> 
 <td>Object mutex = new Object()。对此对象使用synchronized</td> 
 </tr> 
 <tr> 
 <td>JUC中的ConcurrentLinkedQueue</td> 
 <td>ConcurrentLinkedQueue&lt;String&gt; queue = new ConcurrentLinkedQueue();</td> 
 <td></td> 
 </tr> 
 </tbody> 
</table>

# **其他网址** #

[ArrayList 线程安全问题\_Java\_Be yourself.-CSDN博客][ArrayList _Java_Be yourself.-CSDN]

[LinkedList的线程安全处理\_筱白to的博客-CSDN博客\_线程安全的linkedlist][LinkedList_to_-CSDN_linkedlist]

[ArrayList--_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120935697
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95YW54bWwuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: /images/20220828/b2c3bfbe5f2348278802ca27ebff8419.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95YW54bWwuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: /images/20220828/8e046894df0640cbb6b7efee53f5d163.png
[ArrayList _Java_Be yourself.-CSDN]: https://blog.csdn.net/u010416101/article/details/88720974
[LinkedList_to_-CSDN_linkedlist]: https://blog.csdn.net/qq_35872796/article/details/78189537