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

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

我们先来看一个例子：

1. package com.atguigu.signcenter.nosafe;
3. import java.util.ArrayList;
4. import java.util.UUID;
6. /**
7. * 题目：请举例说明集合类是不安全的
8. * @author: jd
9. * @create: 2024-09-02
10. */
11. public class NotSafeDemo {
13.     public static void main(String[] args) {
14.         ArrayList<String> StrList = new ArrayList<>();
15.         for (int i = 0; i <=30 ; i++) {
16.             new Thread(()->{
17.                 StrList.add(UUID.randomUUID().toString().substring(0,8));
18.                 System.out.println("StrList = " + StrList);
19.             },String.valueOf(i)).start();
20.         }
23.     }
25. }

复制代码

结果：从图中可以看出来，实行一段时间之后发生了错误；这个错误就是多线程任务中对同一个集合处理过程中出现了冲突的环境导致的

导致原因&解决方案
会出现ConcurrentModificationException是由于ArrayList的add方法不是线程安全的；当某个线程正在向List中写入数据时，另外一个线程同时进来写入，就会导致ConcurrentModificationException。

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

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

1. private transient volatile Object[] array;
3. public boolean add(E e) {
4.     final ReentrantLock lock = this.lock;
5.     lock.lock();
6.     try {
7.         Object[] elements = getArray();   // 获取当前List中的所有元素
8.         int len = elements.length;  
9.         Object[] newElements = Arrays.copyOf(elements, len + 1);  // 拷贝旧元素到新的扩容的数组中
10.         newElements[len] = e;  // 添加新的值
11.         setArray(newElements);  // 更新
12.         return true;
13.     } finally {
14.         lock.unlock();
15.     }
16. }

复制代码

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

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

复制代码

面这段代码同样会出现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；

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

复制代码

结果正确且正常结束

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。