集合类不安全

List不安全

单线程下：

//单线程十分安全
public class ArrayListTest01 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a","b","c");
        for (String l:list){
            System.out.println(l);
        }
    }
}

多线程下：

//多线程
public class ArrayListTest01 {
    public static void main(String[] args) {

        List<String> list = new ArrayList<>();

        //对比3个线程和30个线程看看区别
        for (int i=0;i<30;i++){
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

解决方法：

• 第一种方法
  Vector类源码底层add方法中含有synchronized，所以是线程安全的
  

• 第二种用Collections类中的synchronizedList方法

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

• 第三种：List list = new CopyOnWriteArrayList<>();
  

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

/**
 * 1 故障现象：ConcurrentModificationException
 * 2 导致原因：add 方法没有加锁
 * 3 解决方案：换一个集合类
 * 1、List<String> list = new Vector<>(); JDK1.0 就存在了！
 * 2、List<String> list = Collections.synchronizedList(new ArrayList<>());
 * Collections类中的方法
 * 3、List<String> list = new CopyOnWriteArrayList<>();
 */
public class ArrayListTest01 {
    public static void main(String[] args) {

        List<String> list = new CopyOnWriteArrayList<>();
        //对比3个线程和30个线程看看区别
        for (int i=0;i<30;i++){
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

写入时复制（CopyOnWrite）思想
写入时复制（CopyOnWrite，简称COW）思想是计算机程序设计领域中的一种优化策略。其核心思想
是，如果有多个调用者（Callers）同时要求相同的资源（如内存或者是磁盘上的数据存储），他们会共
同获取相同的指针指向相同的资源，直到某个调用者视图修改资源内容时，系统才会真正复制一份专用 副本（private
copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的
调用者都是透明的（transparently）。此做法主要的优点是如果调用者没有修改资源，就不会有副本 （private
copy）被创建，因此多个调用者只是读取操作时可以共享同一份资源。
读写分离，写时复制出一个新的数组，完成插入、修改或者移除操作后将新数组赋值给array
CopyOnWriteArrayList为什么并发安全且性能比Vector好
我知道Vector是增删改查方法都加了synchronized，保证同步，但是每个方法执行的时候都要去获得
锁，性能就会大大下降，而CopyOnWriteArrayList 只是在增删改上加锁，但是读不加锁，在读方面的性
能就好于Vector，CopyOnWriteArrayList支持读多写少的并发情况。

set 不安全

同理

HashSet底层是HashMap是线程不安全的，点进去源码看一下

public HashSet() {
        map = new HashMap<>();
    }
    // add方法 就是map的put方法
public boolean add(E e) {
	return map.put(e, PRESENT)==null;
}
//private static final Object PRESENT = new Object(); 不变得值

解决办法

package List;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * 1 故障现象：ConcurrentModificationException
 * 2 导致原因：add 方法没有加锁
 * 3 解决方案：换一个集合类
 * 1、Set<String> set = new HashSet<>(); 默认  //会出现并发修改异常
 * 2、Set<String> set = Collections.synchronizedSet(new HashSet<>());
 * 3、Set<String> set = new CopyOnWriteArraySet();
 * 4 优化建议：（同样的错误，不出现第2次）
 *
 */
public class ArrayListTest01 {
    public static void main(String[] args) {

        Set<String> set = new CopyOnWriteArraySet<>();
        //对比3个线程和30个线程看看区别
        for (int i=0;i<30;i++){
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

map不安全

hashMap底层是数组+链表+红黑树

	Map<String,String> map = new HashMap<>();
	// 等价于
	Map<String,String> map = new HashMap<>(16,0.75);
	// 工作中，常常会自己根据业务来写参数，提高效率

	map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,8));
		System.out.println(map);
		},String.valueOf(i)).start();
	}
}

public class ArrayListTest01 {
    public static void main(String[] args) {
        Map<String,String> map =new HashMap<>();
        //对比3个线程和30个线程看看区别
        for (int i=0;i<30;i++){
            new Thread(()->{
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

解决方法：

public class ArrayListTest01 {
    public static void main(String[] args) {
        Map<String,String> map =new ConcurrentHashMap<>();
        //对比3个线程和30个线程看看区别
        for (int i=0;i<30;i++){
            new Thread(()->{
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}