04_集合类线程不安全问题

Collection线程不安全的举例

单线程环境和多线程下效果如何

单线程环境的ArrayList是不会有问题的

@Test
    public void test1(){
        //单线程是没问题问题的 我们非常熟悉
        List<String> list = new ArrayList<>();
        list.add("dd");
        list.add("aa");
        list.add("bb");
        list.forEach((item)->{
            System.out.println(item);
        });
    }

多线程下

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

java.util.ConcurrentModificationException 我们发现有异常信息 ,ConcurrentModificationException 高并发系统中这个异常太经常了

这个异常是 并发修改的异常

为什么会有这样的问题?

1、当我们执行下面语句的时候，底层进行了什么操作

new ArrayList();
底层创建了一个空的数组，伴随着初始值为10

 /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

当执行add方法后，如果超过了10，那么会进行扩容，扩容的大小为原值的一半，也就是5个，使用下列方法扩容

/**
     * 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;
    }

size++ 我们知道 i++ 是现场不安全的

为什么ArrayList是线程不安全的？因为在进行写操作的时候，方法上为了保证并发性，是没有添加synchronized修饰，所以并发写的时候，就会出现问题
Arrays.copyOf(elementData, netCapacity)

解决方案

上面我们有例子有原因 如何在高并发下保证线程是安全的

方案一：Vector

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

第一种方法，就是不用ArrayList这种不安全的List实现类，而采用Vector，线程安全的

关于Vector如何实现线程安全的，而是在方法上加了锁，即synchronized

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

从这个版本上来看 ArrayList 是为了了增加并发性

这样就每次只能够一个线程进行操作，所以不会出现线程不安全的问题，但是因为加锁了，导致并发性基于下降
这个可以考虑放弃不是使用

方案二：Collections.synchronized()

List list = Collections.synchronizedList(new ArrayList<>());

采用Collections集合工具类，在ArrayList外面包装一层 同步 机制

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

注意:
/**
* 错误的写法
* List list = new ArrayList<>();
* Collections.synchronizedList(list);
*/

方案三：采用JUC里面的方法

CopyOnWriteArrayList：写时复制，主要是一种读写分离的思想

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

就是写的时候，把ArrayList扩容一个出来，然后把值填写上去，在通知其他的线程，ArrayList的引用指向扩容后的

查看底层add方法源码

HashSet线程不安全

CopyOnWriteArraySet
底层还是使用CopyOnWriteArrayList进行实例化

   public CopyOnWriteArraySet(Collection<? extends E> c) {
        if (c.getClass() == CopyOnWriteArraySet.class) {
            @SuppressWarnings("unchecked") CopyOnWriteArraySet<E> cc =
                (CopyOnWriteArraySet<E>)c;
            al = new CopyOnWriteArrayList<E>(cc.al);
        }
        else {
            al = new CopyOnWriteArrayList<E>();
            al.addAllAbsent(c);
        }
    }
     public CopyOnWriteArraySet() {
        al = new CopyOnWriteArrayList<E>();
    }

扩展:

HashSet底层结构
同理HashSet的底层结构就是HashMap
public HashSet() {
map = new HashMap<>();
}
但是为什么我调用 HashSet.add()的方法，只需要传递一个元素，而HashMap是需要传递key-value键值对？

首先我们查看hashSet的add方法

private static final Object PRESENT = new Object();
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

我们能发现但我们调用add的时候，存储一个值进入map中，只是作为key进行存储，而value存储的是一个Object类型的常量，也就是说HashSet只关心key，而不关心value

这个样就好明白原来说的set不能重复的原因了:因为map的可以不允许重复

HashMap线程不安全

同理HashMap在多线程环境下，也是不安全的

  public static void main(String[] args) {

        Map<String, String> map = new HashMap<>();

        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }

解决方法
1、使用Collections.synchronizedMap(new HashMap<>());

2、使用 ConcurrentHashMap

Map<String, String> map = new ConcurrentHashMap<>();