List在高併發場景下保證線程安全的三種方案，CopyOnWriteArrayList寫時複製讀寫分離

Java併發修改異常：java.util.ConcurrentModificationExpection

vector線程安全但是是JDK1.0誕生
arrayList線程不安全但是是JDK 1.2誕生

Collection是一個接口
Collections是一個輔助工具類

目前兩種解決方案：new vector<>();
collctions.synchronizedList(new ArrayList<>());
還有改錯思路思想

//list線程不安全問題，已經舉一個不安全的例子
import java.util.*;

public class ContainerNotSafe {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //1.方案一
        //List<String> list = new Vector<>();

        //2.方案二
        //List<String> list = Collections.synchronizedList(new ArrayList<>());


        //List<Integer> list = Arrays.asList(1, 2, 3);

        //list.forEach(System.out::println);

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

第三種方法
使用new CopyOnWriteArrayList<>();可以保證線程安全

複製後前面指針作廢，並且再最後加上元素

這是add的源碼：

筆記，排錯後的操作

什麼是寫時複製

第三種方式小demo

//list線程不安全問題，已經舉一個不安全的例子
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class ContainerNotSafe {
    public static void main(String[] args) {
        //List<String> list = new ArrayList<>();

        //1.方案一
        //List<String> list = new Vector<>();

        //2.方案二
        //List<String> list = Collections.synchronizedList(new ArrayList<>());

        //3.方案三
        List<String> list = new CopyOnWriteArrayList<>();

        //List<Integer> list = Arrays.asList(1, 2, 3);

        //list.forEach(System.out::println);

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

Set多線程併發不安全問題
hashset底層是hashmap

value恆定present常量

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

public class setNotSafe {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        //方案一
        //Set<Object> set = Collections.synchronizedSet(new HashSet<>());
        //方案二
        //Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i <= 30; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

Map集合多線程併發不安全問題，依然還是那兩種方法

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

public class mapNotSafe {
    public static void main(String[] args) {
        //HashMap<String,String> map = new HashMap<>();
        //方案一
        Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
        //方案二
        //Map<String,String> map = new ConcurrentHashMap<>();
        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();
        }
    }
}