java.util.concurrentModificationExection 并发修改异常

多线程环境下线程不安全的集合类

ArrayList、HashSet、 HashMap....

解决方案：

ArrayList多线程环境下导致并发修改异常的解决方法：

1、使用 new  Vector<>()，因为Vector中的add()方法添加了synchronize的同步关键字，所以在多线程环境下可以解决并发修改异常，但会导致并发量下降。

2、使用Collections.synchronizeList(new ArrayList<>()),也可以解决并发修改异常

3、使用new CopyOnWriteArrayList<>(),写实复制的(读写分离的思想)

写时复制：

CopyOnWrite 容器即写时复制的容器，往一个容器添加元素的时候，不直接往当前的容器Object[]添加，而是先将当前的容器Object[]进行Copy,复制出一个新的容器Object[] newElements,然后往新的容器Object[] newElements 里面添加元素，添加完元素之后，再将原容器的引用指向新的容器setArray(newElements)；这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前的容器不会添加任何元素。所以CopyOnWrite 容器也是 “一种读写分离的思想”，读和写不同的容器。

源码解析如下：

 

 public boolean add(E e) {
            final ReentrantLock lock = this.lock;
            lock.lock();
            try {
                Object[] elements = getArray();
                int len = elements.length;//获取原容器的长度(大小)
                Object[] newElements = Arrays.copyOf(elements, len + 1);//复制一个新的Object 容器
                newElements[len] = e;//往新的Object容器中添加元素
                setArray(newElements);//将原容器的引用指向新容器
                return true;
            } finally {
                lock.unlock();
 }

 

多线程环境下集合类不安全问题的小case，以及解决方法。

package com.company.array.demo;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * 集合类不安全的问题
 * ArrayList
 * HashSet 
 * Map
 *java.util.ConcurrentModificationException 常用集合类多线程下并发 
 *修改异常的解决方案。
 */
public class ContainerNotSafeDemo {
    public static void main(String[] args) {
        listNotSafe();
        setNotSafe();
        mapNotSafe();
    }

    //解决HashMap多线程下面并发修改异常的方法
    public static void mapNotSafe() {
        /*Map<String, String> map = new HashMap<>();*/ //并发修改异常
        /*Map<String, String> map = Collections.synchronizedMap(new HashMap<>());*//方案一
        Map<String, String> map = new ConcurrentHashMap<>();//方案二
        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();
        }
    }

    //解决HashSet多线程下面并发修改异常的方法
    public static void setNotSafe() {
        /*Set<String> set = new HashSet<>();*///多线程下线程不安全。并发修改异常
        /*Set<String>  set= Collections.synchronizedSet(new HashSet<>());*//方案一
        Set<String> set = new CopyOnWriteArraySet<>();// 方案二
        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();
        }
    }

    //解决ArrayList多线程下面并发修改异常的方法
    public static void listNotSafe() {
        /*List<String> list1 = new Vector<>();*///方案一
        /*List<String> list2 = Collections.synchronizedList(new ArrayList<>());*///方案二
        List<String> list = new CopyOnWriteArrayList<>();//方案三
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}