2022.8.21 集合类不安全

6、集合类不安全

1、并发下ArrayList 不安全

 package com.xing.Unsafe;
 ​
 import java.util.*;
 import java.util.concurrent.CopyOnWriteArrayList;
 ​
 public class ListTest {
     public static void main(String[] args) {
         //并发下ArrayList是不安全的   会报错
 ​
         // List<String> list = new ArrayList<>();
         // for (int i =0; i< 10; i++){
         //     new Thread(()->{
         //         list.add(UUID.randomUUID().toString().substring(0,5));
         //         System.out.println(list);
         //     },String.valueOf(i)).start();
         // }
 ​
         /**
          * 解决方案:
          * 1.List<String> list = new Vector<>();
          *
          *集合的顶级：Collections
          * 2.List<String> list = Collections.synchronizedList(Arrays.asList("1", "2", "3"));
          *
          * 3.List<String> list = new CopyOnWriteArrayList<>();
          */
         /** CopyOnWriteArrayList 写入时复制    COW：计算机程序设计领域的一种优化策略；
          *  多个线程调用时，list读取的时候是固定的，写入（存在覆盖）
          *  在写入的时候避免覆盖，造成数据问题
 ​
          *  CopyOnWriteArrayList 比 Vector 好在哪里？  Vector使用了synchronized 效率低
          *  写入的时候复制一份
          */
 ​
         List<String> list = new CopyOnWriteArrayList<>();
         for (int i =0; i< 10; i++){
             new Thread(()->{
                 list.add(UUID.randomUUID().toString().substring(0,5));
                 System.out.println(list);
             },String.valueOf(i)).start();
         }
     }
 }
 ​

 

总结：多个线程调用的时候，List读取的时候是固定的，写入时可能会被覆盖，那么就要先CopyOnWrite写入时复制一份出来调用，调用写完再放回去，再写入的时候避免覆盖，造成数据问题。

CopyOnWriteArrayList 比 Vector牛在哪里

Vector 的 add方法源码：

 // Vector 的 add方法
     public synchronized boolean add(E e) {
         modCount++;
         ensureCapacityHelper(elementCount + 1);
         elementData[elementCount++] = e;
         return true;
     }

Vector用了sychronized同步方法（同步方法自动加锁解锁）效率会很多

CopyOnWriteArrayList 的add方法源码：

 //CopyOnWriteArrayList 的add方法
 ​
      public boolean add(E e) {
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
             Object[] elements = getArray();
             int len = elements.length;//取出长度
             Object[] newElements = Arrays.copyOf(elements, len + 1);//拿出复制
             newElements[len] = e;//并且修改
             setArray(newElements);//让后将数据set回去
             return true;
         } finally {
             lock.unlock();
         }
     }

 

总结：CopyOnWriteArrayList用的是写入时候复制之后再set回去效率而高出很多

2、并发下Set不安全

 package com.xing.Unsafe;
 ​
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CopyOnWriteArraySet;
 ​
 public class SetTest {
     public static void main(String[] args) {
         //ConcurrentModificationException 并发修改异常
         /*
         有问题：与List一样报错   Set<String> strings = new HashSet<>();
         解决方案：Set<String> strings1 = Collections.synchronizedSet(new HashSet<String>());
         最佳解决方案：Set<String> strings = new CopyOnWriteArraySet<>();
         */
         Set<String> strings = new CopyOnWriteArraySet<>();
         for (int i = 0; i < 30; i++) {
             new Thread(()->{
                 strings.add(UUID.randomUUID().toString().substring(0, 5));
                 System.out.println(strings);
             },String.valueOf(i)).start();
         }
     }
 }
 ​

 

HashSet源码

  //HashSet源码：
 ​
     public HashSet() {
         map = new HashMap<>();
     }
 ​
 ​
   //HashSet本质就是 map key是无法重复的
   public boolean add(E e) {
         return map.put(e, PRESENT)==null;
     }
 ​
 ​
 private static final Object PRESENT = new Object();//不变的值

 

3、HashMap不安全

 package com.xing.Unsafe;
 ​
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 ​
 public class MapTest {
     public static void main(String[] args) {
         // HashMap<String, String> hashMap = new HashMap<>();
         //map是这样用的么？ 不是，工作中不用HashMap
         
         
         //默认等价于什么？ new HashMap<>(16,0.75)   第一个为初始化容量,第二个参数为默认的加载因子
         //Map<String,String> map = 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,5));
                 System.out.println(map);
             },String.valueOf(i)).start();
         }
 ​
     }
 }
 ​

 

7、Callable

 

 

 

• 可以有返回值

• 可以抛出异常

• 方法不同 run() / call()

Thread()：参数只能是Runnable，怎么与Callable挂上勾？通过Runnable

 

 

 

 

 

 

 

 

 

FutureTask是个适配类，这里可以看到可以通过FutureTask可以两边互相勾搭使用，Runnavle又和Thread有关系

 package com.xing.Unsafe;
 ​
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;
 ​
 public class CallableTest {
     public static void main(String[] args) throws ExecutionException, InterruptedException {
         // new Thread(new Runnable()).start();
         //Runnable接口的实现类为FutureTask
         //new Thread(new FutureTask<>(Callable)).strat();
 ​
 ​
         MyThread myThread = new MyThread();
 ​
         //适配类，使Callable可以被调用
         FutureTask futureTask = new FutureTask<>(myThread);
 ​
         //两个线程执行会打印几个call
         //一个,结果会被缓存,提高效率,因此只打印一个call
         new Thread(futureTask,"A").start();
         new Thread(futureTask,"B").start();
 ​
         // 获取Callable的返回结果 
         // get方法可能会产生阻塞，把它放到最后，或者使用异步通信
         Integer integer = (Integer)futureTask.get();
         System.out.println(integer);
     }
 }
 ​
 /*
 class MyThread implements Runnable{
     @Override
     public void run() {
 ​
     }
 }*/
 ​
 //<Integer> 代表所需要的返回值
 class MyThread implements Callable<Integer>{
     @Override
     public Integer call() throws Exception {
         System.out.println("call()");
         return 1024;
     }
 }
 ​