List在高并发场景下保证线程安全的三种方案,CopyOnWriteArrayList写时复制读写分离

Java并发修改异常:java.util.ConcurrentModificationExpection

vector线程安全但是是JDK1.0诞生
arrayList线程不安全但是是JDK 1.2诞生

Collection是一个接口
Collections是一个辅助工具类

目前两种解决方案:new vector<>();
collctions.synchronizedList(new ArrayList<>());
还有改错思路思想
List在高并发场景下保证线程安全的三种方案,CopyOnWriteArrayList写时复制读写分离_第1张图片

//list线程不安全问题,已经举一个不安全的例子
import java.util.*;

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

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

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


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

List在高并发场景下保证线程安全的三种方案,CopyOnWriteArrayList写时复制读写分离_第2张图片

第三种方法
使用new CopyOnWriteArrayList<>();可以保证线程安全

复制后前面指针作废,并且再最后加上元素
List在高并发场景下保证线程安全的三种方案,CopyOnWriteArrayList写时复制读写分离_第3张图片

这是add的源码:
List在高并发场景下保证线程安全的三种方案,CopyOnWriteArrayList写时复制读写分离_第4张图片
笔记,排错后的操作
List在高并发场景下保证线程安全的三种方案,CopyOnWriteArrayList写时复制读写分离_第5张图片
什么是写时复制
List在高并发场景下保证线程安全的三种方案,CopyOnWriteArrayList写时复制读写分离_第6张图片
第三种方式小demo

//list线程不安全问题,已经举一个不安全的例子
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

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

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

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

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

        //List 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
List在高并发场景下保证线程安全的三种方案,CopyOnWriteArrayList写时复制读写分离_第7张图片

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 set = Collections.synchronizedSet(new HashSet<>());
        //方案二
        //Set 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 map = new HashMap<>();
        //方案一
        Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
        //方案二
        //Map 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();
        }
    }
}

你可能感兴趣的:(JUC,并发编程)