JUC并发编程——集合类不安全及Callable（基于狂神说的学习笔记）

集合类不安全

List不安全

package unsafe;import PC.A;import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;// ArrayList线程不安全，在多线程下使用ArrayList会报错：
// java.util.ConcurrentModificationException 并发修改异常
public class ListTest {public static void main(String[] args) {// 并发下ArrayList 不安全/*** 解决方案：* 1、List<String> list= new Vector<>();* 实际上，Vector在jdk1.0就已经出来了，ArrayList在jdk1.2才出来* Vector实际上就是在add时将方法synchronized锁起来了* 2、List<String> list = Collections.synchronizedList(new ArrayList<>());// 通过工具类将其转换乘synchronized保证线程安全* 3、List<String> list = new CopyOnWriteArrayList<>();*///List<String> list = new ArrayList<>();//List<String> list = Collections.synchronizedList(new ArrayList<>());List<String> list = new CopyOnWriteArrayList<>();// CopyOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略// 多个线程调用的时候 list，读取的时候，固定的，写入的时候可能会覆盖// 在写入的时候避免覆盖，造成数据问题// CopyOnWriteArrayList比Vector的优势在于，copyOnWriteArrayList在并发下效率要比vector更高，因为CopyOnWriteArrayList使用的是写时复制策略，而非使用synchronized锁for (int i = 1; i <= 10; i++) {new Thread(()->{list.add(UUID.randomUUID().toString().substring(0,5));System.out.println(list);},String.valueOf(i)).start();}}
}

CopyOnWriteArrayList与vector对比，以下来自CSDN智能助手的回答：

Java中的CopyOnWriteArrayList和Vector都是线程安全的动态数组，可以在多线程环境下使用。

CopyOnWriteArrayList使用了一种特殊的写时复制机制，它在对数组进行修改时，会创建一个新的副本，而不是直接在原数组上进行修改。这样可以确保在多线程并发修改时不会发生问题。然而，由于每次修改都需要创建一个新的副本，所以在写入操作频繁的情况下，CopyOnWriteArrayList的性能可能会比较低。

Vector是一个同步的动态数组，它使用了synchronized关键字来保证多线程安全。当多个线程同时修改Vector时，每个线程会依次获得锁，并按顺序执行相应的修改操作。虽然Vector具有线程安全性，但在高并发情况下，由于需要频繁的获取锁和释放锁，可能会导致性能下降。

因此，如果在多线程环境下需要频繁进行读操作，而写操作较少的情况下，CopyOnWriteArrayList可能会更适合。而如果需要频繁进行写操作或者对线程安全性要求不是非常高，可以考虑使用Vector。

而后笔者在IDEA中翻阅关于CopyOnWriteArralyList的add()方法源码发现，它还是使用synchronized关键字，源码如下：

/*** Appends the specified element to the end of this list.** @param e element to be appended to this list* @return {@code true} (as specified by {@link Collection#add})*/
public boolean add(E e) {synchronized (lock) {Object[] es = getArray();int len = es.length;es = Arrays.copyOf(es, len + 1);es[len] = e;setArray(es);return true;}
}

然后笔者去查了文心一言的回答，得到的答案依然是CopyOnWriteArralyList没有使用synchronized锁，回答如下：

CopyOnWriteArrayList的add()方法不是使用synchronized关键字来实现的。实际上，CopyOnWriteArrayList的add()方法内部使用的是一种称为"写时复制"（Copy-on-Write）的技术。

在写时复制策略中，数据结构被修改时，修改操作会在一个新的副本上进行，而不是直接在原始数据上进行。这样，读取操作可以在原始数据上进行，而不需要等待写入操作完成。写入操作完成后，原始数据会被丢弃，新的副本会成为新的原始数据。

在CopyOnWriteArrayList中，当调用add()方法时，它会创建一个新的数组副本，将新元素添加到该副本中，然后将原始数组引用指向新数组。由于创建新数组和修改操作是在一个单独的写锁上进行的，因此多个线程可以同时读取原始数组，而不会看到正在进行的写入操作。

因此，CopyOnWriteArrayList的add()方法并没有使用synchronized关键字来实现线程安全。而是使用写时复制技术和读写锁来实现更细粒度的并发控制。

因此，copyWriteArrayList在并发下是否效率更高有待商榷

Set不安全

package unsafe;import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;public class SetTest {public static void main(String[] args) {// Set<String> set = new HashSet<>(); // 线程不安全// Set<String> set = Collections.synchronizedSet(new HashSet<>());// 通过工具类将其转换成synchronized保证线程安全Set<String> set = new CopyOnWriteArraySet<>();// 通过读写复制策略保证线程安全for (int i = 1; i <= 20; i++) {new Thread(()->{set.add(UUID.randomUUID().toString().substring(0,5));System.out.println(set);},String.valueOf(i)).start();}}
}

hashSet的底层是什么？

HashSet本质上就是HashMap，源码：

/*** Constructs a new, empty set; the backing {@code HashMap} instance has* default initial capacity (16) and load factor (0.75).*/
public HashSet() {map = new HashMap<>();
}// add() set本质就是map key是无法重复的/*** Adds the specified element to this set if it is not already present.* More formally, adds the specified element {@code e} to this set if* this set contains no element {@code e2} such that* {@code Objects.equals(e, e2)}.* If this set already contains the element, the call leaves the set* unchanged and returns {@code false}.** @param e element to be added to this set* @return {@code true} if this set did not already contain the specified* element*/public boolean add(E e) {return map.put(e, PRESENT)==null;}
// PRESENT 是一个常量// Dummy value to associate with an Object in the backing Mapprivate static final Object PRESENT = new Object();

HashMap不安全

ConcurrentHashMap<>()

package unsafe;import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;public class MapTest {public static void main(String[] args) {// 线程不安全// map 是下面这条语句这样用的码？----> 不是，工作中不用HashMap// 默认等价于什么？ -----> Map<String, String> map = new HashMap<>(16,0.75);// Map<String, String> map = new HashMap<>();// 线程安全Map<String,String> map = new ConcurrentHashMap<>();for (int i = 1; i <= 30; i++) {new Thread(()->{map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));System.out.println(map);},String.valueOf(i)).start();}}
}

Callable

特点

1、可以有返回值

2、可以抛出异常

3、方法不同，run() / call()

package callable;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();// 等价于 new Thread(new FutureTask<V>()).start();// new Thread(new FutureTask<V>(Callable)).start();--->FutureTask<V>的构造器为Callablenew Thread().start();// 怎么启动callableMyThread thread = new MyThread();FutureTask futureTask = new FutureTask(thread);// 适配类new Thread(futureTask,"A").start();new Thread(futureTask,"B").start();// 结果会被缓存，提高效率// 这个get方法可能会产生阻塞，加入call()是一个耗时操作，则get需要等待返回值// 一般将get放在最后，或者使用异步通信来处理Integer o = (Integer) futureTask.get();// 获取Callable的返回结果System.out.println(o);}
}class MyThread implements Callable<Integer> {@Overridepublic Integer call() throws Exception {System.out.println("call()");return 1024;}
}