【不安全的集合类】同步容器（如ConcurrentHashMap）、并发集合（如CopyOnWriteArrayList）

news2024/9/21 23:28:52

文章目录

- 一、List的线程不安全
- 二、Set的线程不安全
- 三、Map的线程不安全

日常我们用到的集合的情况会很多，在单线程的情况下，不用考虑到线程安全的问题，但是如果在多线程开发的过程中，我们该选择哪一种类型来保证线程安全性呢
？

一、List的线程不安全

我们先来看一个例子：

package com.atguigu.signcenter.nosafe;

import java.util.ArrayList;
import java.util.UUID;

/**
 * 题目：请举例说明集合类是不安全的
 * @author: jd
 * @create: 2024-09-02
 */
public class NotSafeDemo {

    public static void main(String[] args) {
        ArrayList<String> StrList = new ArrayList<>();
        for (int i = 0; i <=30 ; i++) {
            new Thread(()->{
                StrList.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println("StrList = " + StrList);
            },String.valueOf(i)).start();
        }


    }

}

结果：从图中可以看出来，执行一段时间之后发生了错误；这个错误就是多线程任务中对同一个集合处理过程中出现了冲突的情况导致的
在这里插入图片描述
导致原因&解决方案
会出现ConcurrentModificationException是因为ArrayList的add方法不是线程安全的；当某个线程正在向List中写入数据时，另外一个线程同时进来写入，就会导致ConcurrentModificationException。

我们可以使用线程安全的集合类Vector，其add方法是同步方法（保证了数据一致性，但是访问性能下降）；
使用Collections.synchronizedList(new ArrayList<>()) 创建一个线程安全的List （其实就是在add的时候使用了synchronized同步代码块）；
CopyOnWriteArrayList 写时复制ArrayList （多线程建议使用这个）
Vector是线程安全的，能够保证数据一致性但是性能低；ArrayList牺牲了数据一致性提升了读写效率；现在想要保证数据一致性的同时也要保证读写效率，那应该怎么办？因此出现了读写分离的CopyOnWriteArrayList 。

CopyOnWriteArrayList的写时复制
我们可以先看看CopyOnWriteArrayList中add方法的源码

private transient volatile Object[] array;

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();   // 获取当前List中的所有元素
        int len = elements.length;  
        Object[] newElements = Arrays.copyOf(elements, len + 1);  // 拷贝旧元素到新的扩容的数组中
        newElements[len] = e;  // 添加新的值
        setArray(newElements);  // 更新
        return true;
    } finally {
        lock.unlock();
    }
}

CopyOnWrite容器即写时复制的容器，往一个容器中添加元素的时候，不直接往当前容器Object[]添加，而是现将当前容器Object[]进行Copy，而是复制出一个新的容器Object[] newElements向新容器添加元素，添加之后，再将原容器的引用指向新的容器setArray(newElements)；这样做的好处时可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。同时添加元素的过程是通过ReentrantLock 锁来实现了同一时间内只有一个线程对此方法的访问。

二、Set的线程不安全

public class NotSafeDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }
    }
}

面这段代码同样会出现java.util.ConcurrentModificationException异常；同样可以使用Collections.synchronizedSet()和CopyOnWriteArraySet，其具体原理与List的一致。这里浅说一下HashSet的源码，HashSet其实就是一个HashMap，HashSet的中存的值是HashMap的key，HashMap中的Value是一个固定对象PRESENT。

三、Map的线程不安全

同样HashMap也是线程不安全的，可以使用集合工具类Collections.synchronizedMap(new HashMap<String, String>())和ConcurrentHashMap创建线程安全的HashMap；

public class NotSafeDemo {
    public static void main(String[] args) {
//        HashMap<String, String> map = new HashMap<>();
//        HashMap<String, String> map1 = (HashMap<String, String>) Collections.synchronizedMap(new HashMap<String, String>());
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();
        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }
}