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集合多线程并发不安全问题，依然还是那两种方法

扫描二维码关注公众号，回复： 11217621 查看本文章

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();
        }
    }
}