常用集合线程安全分析

ArrayList在多线程情况下，不安全

具体代码

1. package com.shaonian.juc.list_thread_secure;
3. import java.util.ArrayList;
4. import java.util.List;
5. import java.util.UUID;
7. /**
8. * @author 长名06
9. * @version 1.0
10. * 演示ArrayList集合线程不安全
11. */
12. public class ListDemo {
13.     public static void main(String[] args) {
14.         List<String> list = new ArrayList<>();
16.         for (int i = 0; i < 10; i++) {
17.             new Thread(() -> {
18.                 //会出现java.util.ConcurrentModificationException 并发修改异常
19.                 list.add(UUID.randomUUID().toString().substring(0, 8));
20.                 System.out.println(list);
21.             }, String.valueOf(i)).start();
22.         }
23.     }
24. }

复制代码

解决方案

使用Vector/ConcurrentHashMap集合

1. package com.shaonian.juc.list_thread_secure;
3. import java.util.ArrayList;
4. import java.util.List;
5. import java.util.UUID;
6. import java.util.Vector;
8. /**
9. * @author 长名06
10. * @version 1.0
11. * Vector集合，线程安全 不推荐使用
12. */
13. public class VectorDemo {
14.     public static void main(String[] args) {
15.         List<String> list = new Vector<>();
17.         for (int i = 0; i < 30; i++) {
18.             new Thread(() -> {
19.                 list.add(UUID.randomUUID().toString().substring(0, 8));
20.                 System.out.println(list);
21.             }, String.valueOf(i)).start();
22.         }
23.     }
24. }

复制代码

使用Collections中的synchronizedList()/synchronizedMap()

1. package com.shaonian.juc.list_thread_secure;
3. import java.util.*;
5. /**
6. * @author 长名06
7. * @version 1.0
8. * 使用Collections中的synchronizedList方法，转成对应线程安全的集合，不推荐使用
9. */
10. public class CollectionsDemo {
11.     public static void main(String[] args) {
12.         List<String> list = Collections.synchronizedList(new ArrayList<>());
13.         for (int i = 0; i < 30; i++) {
14.             new Thread(() -> {
15.                 list.add(UUID.randomUUID().toString().substring(0, 8));
16.                 System.out.println(list);
17.             }, String.valueOf(i)).start();
18.         }
19.     }
20. }

复制代码

使用CopyOnwriteArrayList

涉及到写时复制技术，就是说，此集合是可以并发读，但是写操作，同时只能有一个线程执行。写操作时，先将原有的集合内容，copy一份，然后写入新的内容，然后再覆盖原有的集合，覆盖后的集合，就可以读和写了

1. package com.shaonian.juc.list_thread_secure;
3. import java.util.ArrayList;
4. import java.util.Collections;
5. import java.util.List;
6. import java.util.UUID;
7. import java.util.concurrent.CopyOnWriteArrayList;
9. /**
10. * @author 长名06
11. * @version 1.0
12. * 使用线程安全的集合如CopyOnWriteArrayList
13. */
14. public class CopyOnWriteArrayListDemo {
15.     public static void main(String[] args) {
16.         List<String> list = new CopyOnWriteArrayList<>();
17.         for (int i = 0; i < 30; i++) {
18.             new Thread(() -> {
19.                 list.add(UUID.randomUUID().toString().substring(0, 8));
20.                 System.out.println(list);
21.             }, String.valueOf(i)).start();
22.         }
23.     }
24. }

复制代码

CopyOnWriteList

CopyOnWriteList相当于线程安全的ArrayList，和ArrayList一样，它是个可变数组，不过有一下特性

• 1.它最适合具有以下特征的程序使用，List大小通常保持很小，读操作远多于写操作，需要再遍历期间防止线程间的冲突。
  
• 2.线程安全。
  
• 3.可变操作，需要复制整个数组，所以可变操作(add()，set()，remove()等)操作开销大。
  
• 4.迭代器支持hasNext()，next()等不可变操作，但是不支持remove()等操作。
  
• 5.使用迭代器进行遍历的速度会很快，并且不会和其他线程发生冲突，再构造迭代器时，迭代器依赖于不变的数组快照。
  有数组拷贝的操作，会存在一个问题，数据不一致的问题，如果写线程还没来得及写入内存，其他线程就会读到脏数据。但是在CopyOnWriteList中，保存数据的数组，使用volatile关键字修饰，也就是说，当前数组的修改，会被其他线程立刻读取到。保证了一个线程读取volatile修饰的数组，总能看到其他线程对改数组最后的写入，就这样，通过volatile提供了“读取数据总是最新的”这个机制的保证。
  

HashSet和HashMap在多线程情况下，不安全

1. package com.shaonian.juc.list_thread_secure;
3. import java.util.HashSet;
4. import java.util.List;
5. import java.util.Set;
6. import java.util.UUID;
7. import java.util.concurrent.CopyOnWriteArrayList;
9. /**
10. * @author 长名06
11. * @version 1.0
12. */
13. public class HashSetDemo {
14.     public static void main(String[] args) {
15.         //解决方案，使用CopyOnWriteHashSet
16.         Set<String> set = new HashSet<>();
17.         for (int i = 0; i < 30; i++) {
18.             //会出现java.util.ConcurrentModificationException
19.             new Thread(() -> {
20.                 set.add(UUID.randomUUID().toString().substring(0, 8));
21.                 System.out.println(set);
22.             }, String.valueOf(i)).start();
23.         }
24.     }
25. }

复制代码

1. package com.shaonian.juc.list_thread_secure;
3. import java.util.*;
5. /**
6. * @author 长名06
7. * @version 1.0
8. */
9. public class HashMapDemo {
10.     public static void main(String[] args) {
11.         //解决方案，使用ConcurrentHashMap
12.         Map<String,String> map = new HashMap<>();
13.         for (int i = 0; i < 30; i++) {
14.             String key = String.valueOf(i);
15.             //会出现java.util.ConcurrentModificationException
16.             new Thread(() -> {
17.                 map.put(key,UUID.randomUUID().toString().substring(0, 8));
18.                 System.out.println(map);
19.             }, String.valueOf(i)).start();
20.         }
21.     }
22. }

复制代码

小结

线程不安全与其对应的安全集合

集合中存在线程存在和线程不安全的例如ArrayList -- Vector HashMap -- HashTable，但是以上都是syncronized关键字实现的。
Collections构建的线程安全集合

通过使用Collections中的synchronizedList()/synchronizedMap()，将不安全的集合，转成线程安全的。
java.util.concurrent包下的

CopyOnWriteList和CopyOnWriteSet类型，通过动态数组与加锁保证线程安全。
只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。下·

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！