java list 线程安全的有序 list的线程安全问题

一、List

1、ArrayList线程不安全

我们通常使用个ArrayList就是线程不安全的，举个简单的例子

public class ListTest {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        for (int i = 1; i <=40 ; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

多线程环境下操作ArrayList会出现并发修改异常

2、如何解决ArrayList线程不安全

一般来说有三种方式
1、使用Vector
2、使用Collections.synchronizeList()
3、使用CopyOnWriteArrayList()

2.1 Vector

先来看看Vector类

Vector为什么能够解决线程不安全呢？Vector底层采用的是加锁的方式，加锁数据的一致性可以保证，但并发性会大大降低。

public class ListTest {
    public static void main(String[] args) {
       
        List<String> list=new Vector<>();      
        for (int i = 1; i <=40 ; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

2.2 Collections.synchronizeList()

首先来说一下Collection和Collections的区别

Collection是一个接口，Set接口和List接口都继承自此接口

Collections是一个类，一个辅助工具类，可以使不安全的集合类变为安全的。

来看看这个类

public class ListTest {
    public static void main(String[] args) {    
        List<String> list= Collections.synchronizedList(new ArrayList<>());
        for (int i = 1; i <=40 ; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }


    }
}

2.3 CopyOnWriteArrayList()

CopyOnWriteArrayList是JUC包下的一个类。写时复制基于读写分离的思想

public class ListTest {
    public static void main(String[] args) {
        List<String> list=new CopyOnWriteArrayList<>();
        for (int i = 1; i <=40 ; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

来看看CopyOnWrite的add方法，使用Lock来加锁，一次只允许一个线程进行写操作

CopyOnWrite容器被称为写时复制的容器，往一个容器当中添加元素的时候，不直接往当前容器Object[] 添加，而是先将当前的容器Object[] 进行copy，复制出一个新的容器Object[] newElements，往新容器里添加元素，元素添加完成之后，将原容器的引用指向新的容器。

这样做的好处是可以并发的读，而不需要加锁

如果是读多写少的情况，推荐使用CopyOnWriteArrayList；

二、Set

1、HashSet线程不安全

先上代码演示HashSet是线程不安全的，熟悉的配方

public class SetTest {
    public static void main(String[] args) {
        Set<String> set=new HashSet<>();

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

继续报并发修改异常HashSet底层是什么

HashSet底层数据结构就是HashMap

HashMap是以键值对存储数据，而HashSet中的add方法只添加一个元素

value值是一个Object类型的常量，HashSet不关心value值；

2、如何解决HashSet线程不安全

2.1 Collections.synchronizeSet

还是同样的套路

public class SetTest {
    public static void main(String[] args) {
        Set<String> set= Collections.synchronizedSet(new HashSet<>());

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

2.2 CopyOnWriteHashSet

JUC包下的一个类

public class SetTest {
    public static void main(String[] args) {
        Set<String> set=new CopyOnWriteArraySet<>();

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

三、Map

1、HashMap线程不安全

public class SetTest {
    public static void main(String[] args) {
       // Set<String> set=new HashSet<>();
        //Set<String> set= Collections.synchronizedSet(new HashSet<>());
        Set<String> set=new CopyOnWriteArraySet<>();

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

依然报并发修改异常

2、如何解决HashMap线程不安全

2.1 HashTable

来看看HashTable的put方法，加了synchronized关键字，解决了多线程环境下数据一致性的问题，但并发性不高

public class MapTest {
    public static void main(String[] args) {
        Map<String,String> map=new Hashtable<>();
        for(int i=1;i<40;i++){
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

2.1 Collections.synchronizedMap

public class MapTest {
    public static void main(String[] args) {
        //Map<String,String> map=new HashMap<>();
        Map<String,String> map= Collections.synchronizedMap(new HashMap<>());

        for(int i=1;i<40;i++){
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

2.2 ConcurrentHashMap

JUC下的包

public class MapTest {
    public static void main(String[] args) {
        
        Map<String,String> map=new ConcurrentHashMap<>();

        for(int i=1;i<40;i++){
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}