[JUC-05] 集合类不安全

1、集合框架

  集合：集合是java中提供的一种容器，可以用来存储多个数据。

  集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map

2、List 不安全

2.1 ArrayList 并发修改异常

  测试代码：

package pers.klb.myjuc;

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

/**
 * @program: MyJUC
 * @description:
 * @author: Meumax
 * @create: 2020-08-06 11:11
 **/
public class NotSafeDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

  运行结果：

  可以，报了java.util.ConcurrentModificationException异常，叫做并发修改异常。

  我们查看ArrayList的add方法：

  可以分析出：ArrayList的add方法是使用扩容来添加元素，当多个线程同时操作时，会出现一个线程还没来得及加，位置就被其他线程使用了的情况。

2.2 解决1：Vector 替代

  解决方案一就是使用java.util.Vector代替java.util.ArrayList。

package pers.klb.myjuc;

import java.util.List;
import java.util.UUID;
import java.util.Vector;

/**
 * @program: MyJUC
 * @description:
 * @author: Meumax
 * @create: 2020-08-06 11:11
 **/
public class NotSafeDemo {
    public static void main(String[] args) {
        List<String> list = new Vector<String>();
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

  运行结果：

  查看Vector的add方法：

  可见，它是同步方法，因此没有并发问题。

2.3 解决2：synchronizedList 方法

  第二个解决方法就是使用工具类java.util.Collections的synchronizedList()方法来改装ArrayList。这是 JUC 的解决方法。

package pers.klb.myjuc;

import java.util.*;

/**
 * @program: MyJUC
 * @description:
 * @author: Meumax
 * @create: 2020-08-06 11:11
 **/
public class NotSafeDemo {
    public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new ArrayList<String>());

        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

  运行结果：

  查看synchronizedList()方法的源码：

  可见，这个方法重新创建了一个SynchronizedList来代替ArrayList，也就是说，后面调用的add方法，其实是SynchronizedList的add方法，我们查看源码：

  原来是使用了同步代码块，怪不得可以线程同步。

2.4 解决3：CopyOnWriteArrayList 代替

  使用java.util.concurrent.CopyOnWriteArrayList代替ArrayList，这是 JUC 的解决方法。

package pers.klb.myjuc;

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

/**
 * @program: MyJUC
 * @description:
 * @author: Meumax
 * @create: 2020-08-06 11:11
 **/
public class NotSafeDemo {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<String>();

        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

  运行结果：

  查看这个CopyOnWriteArrayList的add方法源码：

  使用了可重入锁来保证并发安全。

  这里还要注意一点：CopyOnWriteArrayList的add方法不是动态扩容，而是一种写入时复制机制，即每次add，不直接往当前容器Object[]添加，而是先将当前容器Object[]进行Copy，复制出一个新的容器Object[] newElements，然后向新的容器Object[] newElements里添加元素。添加元素后，再将原容器的引用指向新的容器setArray(newElements)。这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

   加锁影响性能，不加锁又容易出并发错误，因此，这种写入时复制机制可以兼顾性能和并发。优缺点如下：

  优点：
  1、对于一些读多写少的数据，写入时复制的做法就很不错，例如配置、黑名单、物流地址等变化非常少的数据，这是一种无锁的实现。可以帮我们实现程序更高的并发。
  2、CopyOnWriteArrayList 并发安全且性能比 Vector 好。Vector 是增删改查方法都加了synchronized 来保证同步，但是每个方法执行的时候都要去获得锁，性能就会大大下降，而 CopyOnWriteArrayList 只是在增删改上加锁，但是读不加锁，在读方面的性能就好于 Vector。

  缺点：
  1、数据一致性问题。这种实现只是保证数据的最终一致性，在添加到拷贝数据而还没进行替换的时候，读到的仍然是旧数据。
  2、内存占用问题。如果对象比较大，频繁地进行替换会消耗内存，从而引发 Java 的 GC 问题，这个时候，我们应该考虑其他的容器，例如 ConcurrentHashMap。

3、Set 不安全

3.1 HashSet 并发修改异常

  测试代码：

package pers.klb.myjuc;

import java.util.HashSet;
import java.util.Set;
import java.util.UUID;

/**
 * @program: MyJUC
 * @description:
 * @author: Meumax
 * @create: 2020-08-06 11:45
 **/
public class NotSafeDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        for (int i = 0; i < 15; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }
    }
}

  运行结果：

  出现了java.util.ConcurrentModificationException并发修改异常。

3.2 HashSet 的本质

  其实HashSet的底层是HashMap。

  因此，add()方法其实就是put()方法：

  这个PRESENT为一个 final 的Object对象：

  对 HashMap 不了解的可以附上学习链接：深入浅出HashMap详解（JDK7）、深入浅出HashMap详解（JDK8）、深入浅出ConcurrentHashMap详解

  我们知道，HashMap 是线程不安全的，可替代的技能并发安全又能保证性能的，就是java.util.concurrent.ConcurrentHashMap，因此，我们使用它来代替 Set 或者 Map：

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

public class NotSafeDemo {
    public static void main(String[] args) {
        // Set<String> set = new HashSet<String>();
        Map<String, String> map = new ConcurrentHashMap<>();

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

  运行结果：