集合的线程安全：ArrayList、HashSet、HashMap的线程不安全演示以及解决方法

1. 集合的线程安全

1.1 ArrayList

1.1.1 ArrayList线程不安全演示

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * List集合线程不安全
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                //向集合中添加内容
                list.add(UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
    /*
    Exception in thread "9" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at java.util.AbstractCollection.toString(AbstractCollection.java:461)
	at java.lang.String.valueOf(String.java:2994)
	at java.io.PrintStream.println(PrintStream.java:821)
	at ListDemo.lambda$main$0(ListDemo.java:17)
	at java.lang.Thread.run(Thread.java:748)
     */
}

1.1.2 ArrayList线程不安全解决方案

1.1.2.1 通过Vector解决

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.Vector;

/**
 * List集合线程不安全
 */
public class ListDemo {
    public static void main(String[] args) {
//        List<String> list = new ArrayList<>();

        Vector<Object> vector = new Vector<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                //向集合中添加内容
                vector.add(UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.println(vector);
            }, String.valueOf(i)).start();
        }
    }
}

1.1.2.2 通过Connections工具类解决

import java.util.*;

/**
 * List集合线程不安全
 */
public class ListDemo {
    public static void main(String[] args) {
//        Vector<Object> vector = new Vector<>();
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                //向集合中添加内容
                list.add(UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

1.1.2.3 通过CopyOnWriteArrayList工具类解决（推荐）

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * List集合线程不安全
 */
public class ListDemo {
    public static void main(String[] args) {
//        Vector<Object> vector = new Vector<>();
//        List<String> list = Collections.synchronizedList(new ArrayList<>());
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                //向集合中添加内容
                list.add(UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

原理：写时复制技术

读的时候支持并发读，但是写的时候是先复制一份一模一样的数据，在写完之后再与原来的数据合并，再读合并后的数据。

1.2 HashSet

1.2.1 HashSet线程不安全演示

import java.util.HashSet;
import java.util.Set;
import java.util.UUID;

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> hashSet = new HashSet<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                //向集合中添加内容
                hashSet.add(UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.println(hashSet);
            }, String.valueOf(i)).start();
        }
    }
    /*
    Exception in thread "0" java.util.ConcurrentModificationException
	at java.util.HashMap$HashIterator.nextNode(HashMap.java:1445)
	at java.util.HashMap$KeyIterator.next(HashMap.java:1469)
	at java.util.AbstractCollection.toString(AbstractCollection.java:461)
	at java.lang.String.valueOf(String.java:2994)
	at java.io.PrintStream.println(PrintStream.java:821)
	at HashSetDemo.lambda$main$0(HashSetDemo.java:13)
	at java.lang.Thread.run(Thread.java:748)
     */
}

1.2.2 HashSet线程不安全解决方案

1.2.2.1 通过CopyOnWriteArraySet类来解决

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

public class HashSetDemo {
    public static void main(String[] args) {
//        Set<String> hashSet = new HashSet<>();
        Set<Object> hashSet = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                //向集合中添加内容
                hashSet.add(UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.println(hashSet);
            }, String.valueOf(i)).start();
        }
    }
}

1.3 HashMap

1.3.1 HashMap线程不安全演示

import java.security.Key;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class HashMapDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap();
        for (int i = 0; i < 10; i++) {
            String key = String.valueOf(i);
            new Thread(() -> {
                //向集合中添加内容
                map.put(key, UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
        /*
        Exception in thread "7" Exception in thread "1" Exception in thread "3" Exception in thread "4" Exception in thread "0" Exception in thread "5" java.util.ConcurrentModificationException
         */
    }
}

1.3.2 HashMap线程不安全解决方案

1.3.2.1 通过ConcurrentHashMap类解决

import java.security.Key;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class HashMapDemo {
    public static void main(String[] args) {
//        Map<String, String> map = new HashMap();
        Map<String, String> map = new ConcurrentHashMap();
        for (int i = 0; i < 10; i++) {
            String key = String.valueOf(i);
            new Thread(() -> {
                //向集合中添加内容
                map.put(key, UUID.randomUUID().toString().substring(0, 8));
                //从集合中获取内容
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }
}