22-08-29 西安 JUC（02）线程安全集合类、 juc强大的辅助类

如何理解线程不安全

集合类就相当于一个资源类，并发的多个线程同时操作同一资源类对象时 调用它的成员方法修改成员属性值 如果调用的方法没有加锁 会出现并发的数据安全问题

线程不安全的集合

---

线程不安全List

1、ArrayList演示线程不安全

UUID回顾

String str1 = UUID.randomUUID().toString();//e251ab3e-fa96-478c-b32f-1028db9b396f
String str2 =  UUID.randomUUID().toString().replace("-","");//8f76be380f1346a1b8406ca233129b0e
System.out.println(str1);
System.out.println(str2);

按照8-4-4-4-12的顺序进行分隔。加上中间的横杆，UUID有36个字符。

ArrayList线程不安全演示

List list = new ArrayList<>();
//并发多个线程操作资源类对象
for (int i = 0;i < 30; i++) {
    new Thread(()->{
        list.add(UUID.randomUUID().toString().substring(0,8));
        System.out.println(list);//list.toString()
    },i+"").start();
}

控制台运行报错：并发修改异常

报错分析：

并发的多个线程同时更新集合中的数据，但是集合的方法没有加锁，导致并发的数据安全问题

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

深层次分析：

ArrayList：
    toSting方法执行时 会调用next方法 获取集合中的每一个元素  拼接集合的元素的字符串输出

next方法中 调用了checkForComodification 检查当前方法执行时元素的个数 和 现在集合中元素的个数是否一样。不一样 则抛出并发更新异常 “ConcurrentModificationException”

//以下为ArrayList源码部分
final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

但是ArrayList使用多的原因：
    1、不加锁 性能高
    2、以后Controller或者Servlet的方法  多线程并发访问时，每个方法执行时基本上不会再内部开子线程，一般也不会更新Controller或者Servlet定义的成员变量

每个线程调用的方法形成了一个独立的线程栈 ,不同线程栈中的方法互相独立。

每个方法中的局部变量操作时没有并发线程安全问题的    如果这个方法 使用的是 同一个对象的成员属性 是有并发数据安全问题

---

2、Vector 保证并发的线程安全

//线程安全的List集合类
Vector list = new Vector();
//并发多个线程操作资源类对象
for (int i = 0;i < 30; i++) {
    new Thread(()->{
        list.add(UUID.randomUUID().toString().substring(0,8));
        System.out.println(list);//list.toString()
    },i+"").start();
}

Vector中基本所有的方法都添加了synchronized关键字保证线程安全

包括：CRUD和toString以及iterator()获取迭代器的方法

 Vector 性能较差：内存消耗比较大，适合增量较大的写操作

---

3、SynchronizedList 装饰者模式

是Collections工具类提供的可以将线程不安全的List对象转为(装饰)线程安全的SynchronizedList对象

//线程安全的List集合类
List list = Collections.synchronizedList(new ArrayList<>());
//并发多个线程操作资源类对象
for (int i = 0;i < 30; i++) {
    new Thread(()->{
        list.add(UUID.randomUUID().toString().substring(0,8));
        System.out.println(list);//list.toString()
    },i+"").start();
}

SynchronizedList 中基本上所有的方法 都通过synchronized(this)同步代码块加锁，代码块内的方法体通过创建对象时接收的不安全的List对象相同的方法来实现 【装饰者模式】

SynchronizedList：        ，迭代遍历性能要高于Vector

SynchronizedList 使用场景：适合并发写多 读稍少     使用较多

---

4、CopyOnWriteArrayList 写时复制

CopyOnWrite容器（简称COW容器）即写时复制的容器。

通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器

这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

写操作：不直接修改数据，先拷贝数据的副本，修改副本数据，改成功后使用副本替换原数据

//线程安全的List集合类
CopyOnWriteArrayList list = new CopyOnWriteArrayList();
//并发多个线程操作资源类对象
for (int i = 0;i < 30; i++) {
    new Thread(()->{
        list.add(UUID.randomUUID().toString().substring(0,8));
        System.out.println(list);//list.toString()
    },i+"").start();
}

不会有竞争关系的原理： 每个线程并发时 都是修改自己拷贝的副本数据，多个线程不会修改同一个数据

CopyOnWriteArrayList为了保证同时只有一个线程写数据 ；写/更新的方法使用了ReentrantLock加锁。

在向CopyOnWriteArrayList添加元素时，会复制⼀个新的数组，写操作在新数组上进⾏，读操作在原数组上
进⾏，写操作结束之后会把原数组指向新数组

所有的读的方法均未加锁，读取数据时读取的是当前的集合的数据

cow优缺点：

优点：get/迭代器方法 性能高，未加锁 

CopyOnWriteArrayList允许在写操作时来读取数据，⼤⼤提⾼了读的性能，
因此适合读多写少的应⽤场景

缺点：

1. 内存占用问题。写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存。

2. 数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

CopyOnWriteArrayList 使用场景：适合读多写少场景，比如白名单、黑名单。  尽量少用

---

5、线程安全的List性能测试

    /*
    线程安全的List的性能测试
    先并发写入20w的数据，并发随机读取20w次数据各自的时间
 */
    public static void main(String[] args) {
        List list1 = new Vector();
        //spring-core核心包中提供了StopWatch的工具类  可以帮助我们统计方法执行的时间
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("vector:write");//一次统计开始
        IntStream.rangeClosed(1,200000)
                .parallel() //并行
                .forEach(i->{
                    list1.add(i);
                });
        stopWatch.stop();//一次统计的结束
        stopWatch.start("vector:read");//一次统计开始
        IntStream.rangeClosed(1,200000)
                .parallel() //并行
                .forEach(i->{
                    list1.get(new Random().nextInt(200000));
                });
        stopWatch.stop();//一次统计的结束
        //======================
        List list2 = Collections.synchronizedList(new ArrayList<>());
        stopWatch.start("synchronizedList:write");//一次统计开始
        IntStream.rangeClosed(1,200000)
                .parallel() //并行
                .forEach(i->{
                    list2.add(i);
                });
        stopWatch.stop();//一次统计的结束
        stopWatch.start("synchronizedList:read");//一次统计开始
        IntStream.rangeClosed(1,200000)
                .parallel() //并行
                .forEach(i->{
                    list2.get(new Random().nextInt(200000));
                });
        stopWatch.stop();//一次统计的结束
        //==========
        List list3 = new CopyOnWriteArrayList();
        stopWatch.start("CopyOnWriteArrayList:write");//一次统计开始
        IntStream.rangeClosed(1,200000)
                .parallel() //并行
                .forEach(i->{
                    list3.add(i);
                });
        stopWatch.stop();//一次统计的结束
        stopWatch.start("CopyOnWriteArrayList:read");//一次统计开始
        IntStream.rangeClosed(1,200000)
                .parallel() //并行
                .forEach(i->{
                    list3.get(new Random().nextInt(200000));
                });
        stopWatch.stop();//一次统计的结束
 
        //获取统计结果输出
        System.out.println(stopWatch.prettyPrint());
    }

获取统计结果输出：看得出来时间基本都是cow在写的时候用掉的 

---

线程不安全Set

1、HashSet演示线程不安全

 //HashSet线程不安全测试： ConcurrentModificationException
 Set set = new HashSet();
 //并发多个线程操作资源类对象
 for (int i = 0; i < 30; i++) {
     new Thread(()->{
         set.add(UUID.randomUUID().toString().substring(0,8));
         System.out.println(set);//set.toString()
     },i+"").start();
 }

---

2、synchronizedSet 同步代码块加锁

通过同步代码块加锁，迭代器没有加锁

Set