List不安全

List、ArrayList 等在并发多线程条件下，不能实现数据共享，多个线程同时调用一个list对象时候就会出现并发修改异常ConcurrentModificationException 。

package com.mystpet.list;  
  
import javax.swing.plaf.TableHeaderUI;  
import java.util.ArrayList;  
import java.util.List;  
import java.util.UUID;  
  
public class ListTest {  
    public static void main(String[] args) {  
        List<String> list = new ArrayList<>();  
        for (int i = 1 ; i <= 100; i++) {  
            new Thread(()->{  
                list.add(UUID.randomUUID().toString().substring(0, 5));  
                System.out.println(list);  
            },String.valueOf(i)).start();  
        }  
    }  
}

解决方案：

1. 使用 Vector 类，因为 Vector 的 add 方法带有synchronized 关键字，线程安全（Vector为JDK1.0出的，ArrayList为JDK1.2出的）

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

2. 使用 Collections.synchronizedList 包装 ArrayList类

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

3. 使用 CopyOnWriteArrayList 类，它的 add 方法 使用的是 Lock 的 ReentrantLock锁（可重入锁）

List<String> list = new CopyOnWriteArrayList<>()；

//有人要改数据时，先复制出一份副本，在副本上改。改完了再把旧的替换掉
// CopyOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略 
// 多个线程调用的时候，list，读取的时候，固定的，写入（覆盖） 
// 在写入的时候避免覆盖，造成数据问题！ 
// 读写分离 
// CopyOnWriteArrayList 比 Vector nb 在哪里？ 使用 synchronized 相对 lock 效率低

Set不安全

Set、Hash 等在并发多线程条件下，不能实现数据共享，多个线程同时调用一个set对象时候就会出现并发修改异常ConcurrentModificationException 。

public class SetTest {  
    public static void main(String[] args) {  
        Set<String> set = new HashSet<String>();  
  
        for (int i = 0; i < 100; i++) {  
            new Thread(()->{  
                set.add(UUID.randomUUID().toString().substring(0,5));  
                System.out.println(set);  
            },String.valueOf(i)).start();  
        }  
    }  
}

解决方案：

1. 使使用 Collections.synchronizedSet 包装 HashSet

	Set<String> set = Collections.synchronizedSet(new HashSet<>());

2. 使用 CopyOnWriteArraySet 类，底层和 CopyOnWriteArrayList 类相似，都用了 Lock 的 ReentrantLock锁（可重入锁）

    Set<String> set = new CopyOnWriteArraySet<>();

HashSet底层是什么

本质:

	public HashSet() { 
		map = new HashMap<>(); 
	}

add 方法的本质：

// set 本质就是 map的key，key是无法重复的
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

// 与支持 Map 中的对象关联的虚拟值
private static final Object PRESENT = new Object();	// 不变的值

Map不安全

回顾Map的基本操作

import java.util.HashMap;  
import java.util.Map;  
import java.util.UUID;  
  
public class MapTest {  
    public static void main(String[] args) {  
    
	    // map 是这样用的吗？ 不是，工作中不用 HashMap 
	    // 默认等价于什么？ new HashMap<>(16, 0.75);
        Map<String,String> map = new HashMap<>();  
  
        for (int i = 1; i <=50 ; i++) {  
            new Thread(()->{  
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));  
                System.out.println(map);  
            },String.valueOf(i)).start();  
        }  
    }  
}

解决方案：

1. 使用 Collections.synchronizedMap 包装 HashMap

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

2. 使用 ConcurrentHashMap 类

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