集合的线程安全解读

一个风轻云淡

已于 2023-07-19 12:38:02 修改

阅读量353

点赞数 3

分类专栏： JUC并发编程文章标签： java jvm c++ 开发语言面试

于 2023-04-10 08:38:24 首次发布

本文链接：https://blog.csdn.net/m0_62436868/article/details/129758783

版权

JUC并发编程专栏收录该内容

31 篇文章 4 订阅

订阅专栏

集合操作 Demo

Vector

Collections

CopyOnWriteArrayList(重点)

“动态数组”机制

“线程安全”机制

集合操作 Demo

NotSafeDemo

public class NotSafeDemo {

    /**
     * 多个线程同时对集合进行修改
     * @param args
     */
    public static void main(String[] args) {
        List list = new ArrayList();

        for (int i = 0; i < 100; i++) {
            new Thread(() ->{
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            }, "线程" + i).start();
        }
    }
}

异常内容 java.util.ConcurrentModificationException

问题: 为什么会出现并发修改异常?

查看 ArrayList 的 add 方法源码

/** 

* Appends the specified element to the end of this list. 
* @param e element to be appended to this list 
* @return <tt>true</tt> (as specified by {@link Collection#add}) 
*/ 

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

ConcurrentModificationException异常通常意味着多个线程并发访问了同一个集合，并且有一个线程正在迭代该集合的时候，另一个线程修改了集合的结构，导致迭代器的迭代状态发生了不一致的情况，因此抛出了ConcurrentModificationException异常。

在ArrayList中，迭代器使用一个内部变量modCount来判断集合是否被修改过，而modCount的值会在每次添加或删除元素时递增。当多个线程并发执行ArrayList的add操作时，有可能会导致modCount值和迭代器的迭代状态不一致。当一个线程正在迭代ArrayList时，另一个线程修改了ArrayList的结构，这会导致modCount的值发生改变，而此时迭代器的迭代状态还是基于之前的modCount值，最终导致迭代器抛出ConcurrentModificationException异常。

==那么我们如何去解决 List 类型的线程安全问题?==

Vector

Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。 Vector 继承了 AbstractList，实现了 List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。 Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。 RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在 Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。 Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。

==和 ArrayList 不同，Vector 中的操作是线程安全的。==

public class NotSafeDemo {

    /**
     * 多个线程同时对集合进行修改
     *
     * @param args
     */
    public static void main(String[] args) {
        List list = new Vector();

        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            }, "线程" + i).start();
        }
    }
}

现在没有运行出现并发异常,为什么? 查看 Vector 的 add 方法

/** 

* Appends the specified element to the end of this Vector. 
* @param e element to be appended to this Vector 
* @return {@code true} (as specified by {@link Collection#add}) 
* @since 1.2 
*/ 

public synchronized boolean add(E e) { 
 modCount++; 
 ensureCapacityHelper(elementCount + 1); 
 elementData[elementCount++] = e; 
 return true; 

}

add 方法被 synchronized 同步修辞,线程安全!因此没有并发异常

Collections

Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的

NotSafeDemo 代码修改

public class NotSafeDemo {

    /**
     * 多个线程同时对集合进行修改
     *
     * @param args
     */
    public static void main(String[] args) {
        List list = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            }, "线程" + i).start();
        }
    }
}

没有并发修改异常查看方法源码

/** 

* Returns a synchronized (thread-safe) list backed by the specified 
* list. In order to guarantee serial access, it is critical that 
* <strong>all</strong> access to the backing list is accomplished 
* through the returned list.<p> 
* 
* It is imperative that the user manually synchronize on the returned 
* list when iterating over it: 
* <pre> 
* List list = Collections.synchronizedList(new ArrayList()); 
* ... 
* synchronized (list) { 
* Iterator i = list.iterator(); // Must be in synchronized block 
* while (i.hasNext()) 
* foo(i.next()); 
* } 
* </pre> 
* Failure to follow this advice may result in non-deterministic behavior. 
* 
* <p>The returned list will be serializable if the specified list is 
* serializable. 
* 
* @param <T> the class of the objects in the list 
* @param list the list to be "wrapped" in a synchronized list. 
* @return a synchronized view of the specified list. 
*/ 

public static <T> List<T> synchronizedList(List<T> list) { 
 return (list instanceof RandomAccess ? 
 new SynchronizedRandomAccessList<>(list) : 
 new SynchronizedList<>(list)); 
}

CopyOnWriteArrayList(重点)

首先我们对 CopyOnWriteArrayList 进行学习,其特点如下: 它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和 ArrayList 不同的时，它具有以下特性：

1. 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。

2. 它是线程安全的。

3. 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。

4. 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。

5. 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

1. 独占锁效率低：采用读写分离思想解决

2. 写线程获取到锁，其他写线程阻塞

复制思想：

当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。

这时候会抛出来一个新的问题，也就是数据不一致的问题。如果写线程还没来得及写会内存，其他的线程就会读到了脏数据。

==这就是 CopyOnWriteArrayList 的思想和原理。就是拷贝一份。==

NotSafeDemo 代码修改

public class NotSafeDemo {

    /**
     * 多个线程同时对集合进行修改 
     * @param args
     */
    public static void main(String[] args) {
        List list = new CopyOnWriteArrayList();
        for (int i = 0; i < 100; i++) {
            new Thread(() ->{
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            }, "线程" + i).start();
        }
    }
}

没有线程安全问题

原因分析(重点):

==动态数组与线程安全== 下面从“动态数组”和“线程安全”两个方面进一步对CopyOnWriteArrayList 的原理进行说明。

“动态数组”机制

o 它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因

o 由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的操作，CopyOnWriteArrayList 效率很低；但是单单只是进行遍历查找的话，效率比较高。

“线程安全”机制

o 通过 volatile 和互斥锁来实现的。

o 通过“volatile 数组”来保存数据的。一个线程读取 volatile 数组时，总能看到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读取到的数据总是最新的”这个机制的保证。

o 通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥锁”，就达到了保护数据的目的。