Java-List on 计算机知识分享网

【java-list】源码解析ArrayList的多线程相关原理

986945193@qq.com (David) — Fri, 09 Dec 2022 10:40:29 +0800

一、`ArrayList`概述

ArrayList是基于数组实现的，是一个动态的数字，可以自动扩容。

ArrayList不是线程安全的，效率比较高，只能用于单线程的环境中，在多线程环境中可以使用Collections.synchronizedList(List list)函数返回一个线程安全的ArrayList集合，或者使用concurrent并发包下的CopyOnWriteArrayList。

// 使用Collections.synchronizedList(List list)方法实现线程安全
List<?> list=Collections.synchronizedList(new ArrayList<>());

二、通过源码解析`Collections.synchronizedList（List list）`方法如何实现线程安全？

public static List synchronizedList(List list1) {
 return ((List) ((list1 instanceof RandomAccess) ? new SynchronizedRandomAccessList(list1)
 : new SynchronizedList(list1)));
}

通过判断传入的list类是否为RandomAccess类，如果是则实例化SynchronizedRandomAccessList，如果不是，则实例化SynchronizedList。如果你传入的list集合是ArrayList或者Vector。那么则是实例化SynchronizedRandomAccessList。我们从源码可以查看原因：

ArrayList集合源码：

public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable {

Vector集合源码：

public class Vector extends AbstractList implements List, RandomAccess, Cloneable, Serializable {

我们可以发现ArrayList和Vector集合两者都实现了List和RandomAccess接口。接下来看看SynchronizedRandomAccessList类的实现：

static class SynchronizedRandomAccessList extends SynchronizedList implements RandomAccess {

 public List subList(int i, int j)
 {
 Object obj = mutex;
 return new SynchronizedRandomAccessList(list.subList(i, j), mutex);
 }

 private Object writeReplace() {
 return new SynchronizedList(list);
 }

 private static final long serialVersionUID = 1530674583602358482L;

 SynchronizedRandomAccessList(List list1) {
 super(list1);
 }

 SynchronizedRandomAccessList(List list1, Object obj) {
 super(list1, obj);
 }
 }

因为SynchronizedRandomAccessList这个类继承自SynchronizedList，而大部分方法都在SynchronizedList中实现了，所以源码中只包含了很少的方法。我们来看看SynchronizedList的源码：

static class SynchronizedList<E>
 extends SynchronizedCollection<E>
 implements List<E> {
 private static final long serialVersionUID = -7754090372962971524L;

 final List<E> list;

 SynchronizedList(List<E> list) {
 super(list);
 this.list = list;
 }
 SynchronizedList(List<E> list, Object mutex) {
 super(list, mutex);
 this.list = list;
 }

 public boolean equals(Object o) {
 if (this == o)
 return true;
 synchronized (mutex) {return list.equals(o);}
 }
 public int hashCode() {
 synchronized (mutex) {return list.hashCode();}
 }

 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);}
 }

 public int indexOf(Object o) {
 synchronized (mutex) {return list.indexOf(o);}
 }
 public int lastIndexOf(Object o) {
 synchronized (mutex) {return list.lastIndexOf(o);}
 }

 public boolean addAll(int index, Collection<? extends E> c) {
 synchronized (mutex) {return list.addAll(index, c);}
 }

 public ListIterator<E> listIterator() {
 return list.listIterator(); // Must be manually synched by user
 }

 public ListIterator<E> listIterator(int index) {
 return list.listIterator(index); // Must be manually synched by user
 }

 public List<E> subList(int fromIndex, int toIndex) {
 synchronized (mutex) {
 return new SynchronizedList<>(list.subList(fromIndex, toIndex),
 mutex);
 }
 }

 @Override
 public void replaceAll(UnaryOperator<E> operator) {
 synchronized (mutex) {list.replaceAll(operator);}
 }
 @Override
 public void sort(Comparator<? super E> c) {
 synchronized (mutex) {list.sort(c);}
 }

}

可以发现SynchronizedList方法中地方都用到了同步锁，并且参数都是mutex。我们通过点击mutex字段进入到SynchronizedCollection类中，可以得知mutex是在SynchronizedCollection类中定义的。我们继续查看SynchronizedCollection部分源码：

static class SynchronizedCollection<E> implements Collection<E>, Serializable {
 private static final long serialVersionUID = 3053995032091335093L;
 final Collection<E> c; // Backing Collection
 final Object mutex; // Object on which to synchronize

 SynchronizedCollection(Collection<E> c) {
 if (c==null)
 throw new NullPointerException();
 this.c = c;
 mutex = this;
 }

 SynchronizedCollection(Collection<E> c, Object mutex) {
 this.c = c;
 this.mutex = mutex;
 }
}

可以发现其实我们调用synchronizedList方法的使用，内部锁都是一样的，所以它可以实现线程的同步。

三、通过源码解析`CopyOnWriteArrayList`如何做到线程安全的？

CopyOnWriteArrayList使用了一种叫写时复制的方法，当有新元素添加到CopyOnWriteArrayList时，先从原有的数组中拷贝一份出来，然后在新的数组做写操作，写完之后，再将原来的数组引用指向到新数组。

当有新元素加入的时候，如下图，创建新数组，并往新数组中加入一个新元素,这个时候，array这个引用仍然是指向原数组的。 1list

当元素在新数组添加成功后，将array这个引用指向新数组。 2list

CopyOnWriteArrayList的整个add操作都是在锁的保护下进行的。这样做是为了避免在多线程并发add的时候，复制出多个副本出来,把数据搞乱了，导致最终的数组数据不是我们期望的。我们来看看CopyOnWriteArrayList源码：

 transient final ReentrantLock lock = new ReentrantLock();

 /** The array, accessed only via getArray/setArray. */
 private volatile transient Object[] array;//保证了线程的可见性

 public boolean add(E e) {
 final ReentrantLock lock = this.lock;//ReentrantLock 保证了线程的可见性和顺序性，即保证了多线程安全。
 //1、先加锁
 lock.lock();
 try {
 Object[] elements = getArray();
 int len = elements.length;
 Object[] newElements = Arrays.copyOf(elements, len + 1);////2、拷贝数组,在原先数组基础之上新建长度＋1的数组，并将原先数组当中的内容拷贝到新数组当中。

 //3、将元素加入到新数组中
 newElements[len] = e;
 //4、将array引用指向到新数组
 setArray(newElements);//对新数组进行赋值
 return true;
 } finally {
 lock.unlock();
 }
 }

由于所有的写操作都是在新数组进行的，这个时候如果有线程并发的写，则通过锁来控制，如果有线程并发的读，则分几种情况：

如果写操作未完成，那么直接读取原数组的数据；
如果写操作完成，但是引用还未指向新数组，那么也是读取原数组数据；
如果写操作完成，并且引用已经指向了新的数组，那么直接从新数组中读取数据。

可见，CopyOnWriteArrayList的读操作是可以不用加锁的。

四、`Collections.synchronizedList` & `CopyOnWriteArrayList`

CopyOnWriteArrayList和Collections.synchronizedList是实现线程安全的列表的两种方式。两种实现方式分别针对不同情况有不同的性能表现，其中CopyOnWriteArrayList的写操作性能较差，而多线程的读操作性能较好。而Collections.synchronizedList的写操作性能比CopyOnWriteArrayList在多线程操作的情况下要好很多，而读操作因为是采用了synchronized关键字的方式，其读操作性能并不如CopyOnWriteArrayList。因此在不同的应用场景下，应该选择不同的多线程安全实现类。

【java-list】源码解析多线程中list空指针和size大小异常问题

986945193@qq.com (David) — Fri, 09 Dec 2022 10:36:11 +0800

问题描述

为了效率，使用Stream并行流parallelStream来遍历源list往宿list添加元素，后面在遍历宿list（LinkedList）的时候会偶发性报NullPointerException空指针异常或list size大小异常。（如果宿list使用的是ArrayList，那么还可能会报ArrayIndexOutOfBoundsException数组越界异常）

测试代码源码

package com.david.jdk8;


import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * @author David Zheng
 * @date 2022/12/08
 * @email dmcxiaobing@foxmail.com
 * <p>
 * 线程安全相关的
 */

public class ThreadSafeList {
 public static void main(String[] args) {
 //执行开始时间(记录耗时)
 Long start = System.currentTimeMillis();
 //先造数据
 //ArrayList和LinkedList选用:查询多用ArrayList增删多用LinkedList
 //为了后面并行流parallelStream可以更快执行,这里选用ArrayList,因为流的可拆分性能上ArrayList比LinkedList好很多
 List<Integer> sourceList = new ArrayList<>();
 //可自行调整i大小测试
 for (int i = 1; i <= 20; i++) {
 sourceList.add(i);
 }
 //这里使用线程安全的并发容器ConcurrentLinkedQueue,配合并行流,防止多线程修改共享变量触发多线程安全问题
 List<Integer> targetList = new LinkedList<>();//遍历时可能会报空指针异常且size异常
 //List<Integer> targetList = new ArrayList<>();//遍历时可能会报空指针异常且size异常
 //解决方案
 //ConcurrentLinkedQueue<Integer> targetList = new ConcurrentLinkedQueue<>();
 //LinkedBlockingQueue<Integer> targetList = new LinkedBlockingQueue<>();
 //CopyOnWriteArrayList<Integer> targetList = new CopyOnWriteArrayList<>();
 //实际使用时尽量使用LongStream/ IntStream/DoubleStream 等原始数据流代替 Stream 来处理数字，
 //以避免频繁拆装箱带来的额外开销要考虑流的操作流水线的总计算成本
 //并行流内部使用了默认的 ForkJoinPool 线程池
 try {
 sourceList.parallelStream().forEach(
 item -> {
 if (item != null) {
 //如果是ArrayList，多线程时可能会报数组越界异常
 targetList.add(item);
 }
 });
 } catch (Exception e) {
 System.out.println("出现异常了");
 e.printStackTrace();
 throw e;
 }

 Iterator iterator = targetList.iterator();
 while (iterator.hasNext()) {
 try {
 Integer item = (Integer) iterator.next();
 System.out.println(item);
 } catch (Exception e) {
 System.out.println("出现异常了");
 e.printStackTrace();
 throw e;
 }
 }
 //执行结束时间
 Long end = System.currentTimeMillis();
 System.out.println("完成,本次任务耗时" + (end - start) / (1000) + "秒,targetList的size：" + targetList.size());
 }
}

运行结果

如果list用的LinkedList ，可能会出现以下情况（NullPointerException空指针异常或list size大小也有问题） LinkedList

如果list用的ArrayList ，除可能出现上述LinkedList的问题，还可能会出现以下情况（ArrayIndexOutOfBoundsException数组越界异常） ArrayList

`list`用的`LinkedList`时原因分析：

先总结：parallelStream并行流实际上是多线程操作，如果多线程操作共享变量就很容易出现线程安全问题。（ArrayList和LinkedList都是线程不安全的！）
不开启多线程的时候targetList的size一定是sourceList的size大小，而且不会出现空指针异常。

这两个问题其实都和size++这句话有关

1、size大小为什么不是1000

分析源码：

add是尾插，源码如下

void linkLast(E e) {
 final Node<E> l = last;
 final Node<E> newNode = new Node<>(l, e, null);
 last = newNode;
 if (l == null)
 first = newNode;
 else
 l.next = newNode;
 size++;
 modCount++;
}

模拟一个场景

size现在的值为100
线程a拿到了size大小100，此时cpu让出执行权给线程b
线程b拿到了size大小也为100
那么无论他们谁先加1，最后size的值会被101覆盖两次，导致size的大小不会是102

2、再次遍历target的时候为什么会报空指针异常问题

其实也和尾插法这段代码有关

模拟场景：

设现在的size为100

线程a拿到了链表尾部元素last 之后让出执行权给线程b

线程b也拿到了相同的last之后一直执行完了add操作，此时size = 101

线程a也执行了 l.next = newNode;覆盖了线程b的在size = 101 位置上的值，

之后也进行了size++的操作，size = 102

此时出现的问题就是size = 101 位置上的值被覆盖了两次，但是102位置上的值是null。

所以遍历的时候会报空指针异常。

因为last = newNode;这一步的重复覆盖，可以预测所有的null都会是链表末尾。（参考上面的图）

3、关于为什么foreach增强for循环为什么会报空指针的问题

Linkedlist的foreach循环，是依赖Iterator的，LinkedList也有自己的迭代器，源码如下 Iterator

可以看出hasnext的判断并不是node.next != null 而是 nextIndex < size 所以即使null都在末尾也会在 next = next.next的时候报空指针异常。

`list`用的`ArrayList`时：

其实也是和size++有关，与LinkedList不同的是由于实现尾插的方式不一致，所以导致null可能在中间。（参考上面的图）

分析源码：

ArrayList的add方法如下：

public boolean add(E e) {
 ensureCapacityInternal(size + 1); 
 elementData[size++] = e;
 return true;
}

线程不安全问题的关键在于这行代码：elementData[size++] = e

其原子操作如下：

1. elementData[size] = e
2. 读取 size
3. size += 1

在多线程环境下，当两个线程同时执行ensureCapacityInternal(size + 1)得到了相同的size（假设此时size恰好为数组最后一位），没有触发扩容，此时线程A先一步执行完size+1，而后线程B读取到这个新的size，而后再次size+1，此时就会出现数组越界异常。

解决办法

使用线程安全的ArrayList：CopyOnWriteArrayList
使用线程安全的LinkedList：ConcurrentLinkedQueue、LinkedBlockingQueue
让需要进行add操作的list，转换成线程安全的：

List<String> target = Collections.synchronizedList(new LinkedList<>())

`SynchronizedList`：

SynchronizedList是通过对读写方法使用synchronized修饰来实现同步的，即便只是多个线程在读数据，也不能进行，如果是读比较多的场景下，会性能不高，所以适合读写均匀的情况。

`ConcurrentLinkedQueue`、`LinkedBlockingQueue`：

LinkedBlockingQueue是使用锁机制，ConcurrentLinkedQueue是使用CAS算法，虽然LinkedBlockingQueue的底层获取锁也是使用的CAS算法；

关于取元素，ConcurrentLinkedQueue不支持阻塞去取元素，LinkedBlockingQueue 支持阻塞的take()方法，如若大家需要ConcurrentLinkedQueue的消费者产生阻塞效果，需要自行实现；

关于插入元素的性能，从字面上和代码简单的分析来看ConcurrentLinkedQueue肯定是最快的，但是这个也要看具体的测试场景，我做了两个简单的demo做测试，测试的结果如下，两个的性能差不多，但在实际的使用过程中，尤其在多cpu的服务器上，有锁和无锁的差距便体现出来了，ConcurrentLinkedQueue会比LinkedBlockingQueue快很多。

`CopyOnWriteArrayList`：

CopyOnWriteArrayList是读写分离的，只对写操作加锁，但是每次写操作(添加和删除元素等)时都会复制出一个新数组，完成修改后，然后将新数组设置到旧数组的引用上，所以在写比较多的情况下，会有很大的性能开销，所以适合读比较多的应用场景。

Java-List on 计算机知识分享网

【java-list】源码解析ArrayList的多线程相关原理

一、ArrayList概述

二、通过源码解析Collections.synchronizedList（List list）方法如何实现线程安全？

ArrayList集合源码：

Vector集合源码：

三、通过源码解析CopyOnWriteArrayList如何做到线程安全的？

四、Collections.synchronizedList & CopyOnWriteArrayList

【java-list】源码解析多线程中list空指针和size大小异常问题

问题描述

测试代码源码

运行结果

list用的LinkedList时 原因分析：

这两个问题其实都和size++这句话有关

1、size大小为什么不是1000

分析源码：

2、 再次遍历target的时候为什么会报空指针异常问题

3、 关于为什么foreach增强for循环为什么会报空指针的问题

list用的ArrayList时：

分析源码：

解决办法

SynchronizedList：

ConcurrentLinkedQueue、LinkedBlockingQueue：

CopyOnWriteArrayList：

一、`ArrayList`概述

二、通过源码解析`Collections.synchronizedList（List list）`方法如何实现线程安全？

三、通过源码解析`CopyOnWriteArrayList`如何做到线程安全的？

四、`Collections.synchronizedList` & `CopyOnWriteArrayList`

`list`用的`LinkedList`时原因分析：

2、再次遍历target的时候为什么会报空指针异常问题

3、关于为什么foreach增强for循环为什么会报空指针的问题

`list`用的`ArrayList`时：

`SynchronizedList`：

`ConcurrentLinkedQueue`、`LinkedBlockingQueue`：

`CopyOnWriteArrayList`：