1.汇合类不平安之并发批改异样
2.汇合类不平安之加锁和写时复制
3.汇合类不平安之SET
4.汇合类不平安之MAP
1.汇合类不平安之并发批改异样
本次咱们来解说汇合类线程不平安操作的问题，咱们先来看一看个别状况下，咱们是如何操作汇合类的：
List<String> list = new ArrayList<>();;
list.add("a");
list.add("b");
list.add("c");一般来说，没有什么简单的高并发业务逻辑场景的话，咱们都是简略地对list进行add操作，然而，在高并发场景下呢？接下来咱们模仿一下多线程操作一个list，会呈现什么样的状况：
//创立了三千个线程，对一个list进行随机减少字符串
List<String> list = new ArrayList<>();;
for (int i = 0; i < 3000; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
}, String.valueOf(i)).start();
}运行一下，后果报了异样：
!
java.util.ConcurrentModificationException
显示JAVA并发批改异样，这是因为多线程同时在操作一个对象。
（举个例子，一个班有三千名学生，同时在往一签到表上写名字进行签到，然而如果不遵循先来后到准则的话，就会产生哄抢景象，签到表会坏掉。）
2.汇合类不平安之加锁和写时复制
此时，有两个解决办法：
办法一：
List<String> list = Collections.synchronizedList(new ArrayList<>());
咱们先来尝试一下：
List<String> list = Collections.synchronizedList(new ArrayList<>());
for (int i = 0; i < 3000; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
}, String.valueOf(i)).start();
}运行后果没有问题：
为什么应用Collections.synchronizedList()办法咱们就能够将这个list变为线程平安的list呢，咱们来看一下源码：
public static <T> List<T> synchronizedList(List<T> list) {
return (list instanceof RandomAccess ?
new SynchronizedRandomAccessList<>(list) :
new SynchronizedList<>(list));
}把ArrayList类传进去后，会进行类型判断，因为ArrayList实现了RandomAccess接口(是一个标记接口，表明实现这个这个接口的 List 汇合是反对疾速随机拜访的，具体咱们不开展)，所以会调用
new SynchronizedRandomAccessList<>(list)而后就会调用
SynchronizedList(List<E> list) {
super(list);
this.list = list;
}此时，list是一个final对象
final List<E> list;final就代表这个list被赋值一次就不能再被赋值了，然而list里的内容还是可能add和remove的。
接下来，咱们看一下最重要的办法add：
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}mutex是一个互斥变量，学过操作系统的人都晓得，谁领有mutex，谁就能进入这个办法进行操作，而别的线程只能在里面期待。
Collections.synchronizedList(new ArrayList<>());下面这个类对list的办法进行了再封装，进行同步的add操作。
办法二：
List<String> list = new CopyOnWriteArrayList<>()他的add办法在多线程的状况下也是不会报错的，在这里咱们就不演示了，接下来咱们来看一下源码，首先是构造方法：
new CopyOnWriteArrayList<>()点进去之后
public CopyOnWriteArrayList() {
setArray(new Object[0]);
} final void setArray(Object[] a) {
array = a;
} private transient volatile Object[] array;他会先设置一个长度为0的object数组,并且这个array是volatile的Object数组，留神一下volatile的个性（可见性，禁止指令重排，然而不保障原子性）。
接下来咱们看一下，CopyOnWriteArrayList最重要的add办法是怎么保障线程平安的。
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
// 先获取当初的数组对象
Object[] elements = getArray();
int len = elements.length;
//将当初的数组对象进行扩容+1后，取的新的数组对象
Object[] newElements = Arrays.copyOf(elements, len + 1);
//将新元素放在数组最初的地位上
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}由此源码，咱们能够看到，add办法先后进行了
复制->扩容->放入最初一个地位 这三个操作。
并且还应用了加锁机制，每次只能有一个线程能进入这个办法。
还有volatile关键字：
每次应用array数组的时候，确保是从内存中取到的最新的数值。
3.汇合类不平安之SET
因为list，set，map都是线程不平安的，多线程操作都会引起异样，所以咱们就不演示了。
创立汇合平安的类，有两种办法
//这种形式的add办法和synchronizedList形式并没有区别
Set<String> set = Collections.synchronizedSet(new HashSet<>());
//咱们重点看第二种
Set<String> set = new CopyOnWriteArraySet();咱们先看构造方法
/**
* Creates an empty set.
*/
public CopyOnWriteArraySet() {
al = new CopyOnWriteArrayList<E>();
}private final CopyOnWriteArrayList<E> al;可见CopyOnWriteArraySet的底层是arrayList（这里不要被我误导了，HashSet的底层是HashMap,只不过value都是Object而已，只是咱们当初看到的CopyOnWriteArraySet，底层是ArrayList）
咱们来看一下最重要的add办法：
public boolean add(E e) {
return al.addIfAbsent(e);
} /**
* Appends the element, if not present.
*
* @param e element to be added to this list, if absent
* @return {@code true} if the element was added
*/
public boolean addIfAbsent(E e) {
Object[] snapshot = getArray();
return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
addIfAbsent(e, snapshot);
}咱们能够看到注解说，如果没有这个元素，就增加，否则就不增加。
indexOf是判断这个元素是否在set内存在并返回索引的，如果大于等于0就不存在，接着会调用addIfAbsent办法：
/**
* A version of addIfAbsent using the strong hint that given
* recent snapshot does not contain e.
*/
private boolean addIfAbsent(E e, Object[] snapshot) {
//加锁操作
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] current = getArray();
int len = current.length;
//如果传进来的值和本地数组援用不是一个地址
//咱们就要进行比对，如果发现了未增加的元素曾经在数组里了，就返回false
if (snapshot != current) {
// Optimize for lost race to another addXXX operation
int common = Math.min(snapshot.length, len);
for (int i = 0; i < common; i++)
if (current[i] != snapshot[i] && eq(e, current[i]))
return false;
if (indexOf(e, current, common, len) >= 0)
return false;
}
//也是采取了写时复制办法
Object[] newElements = Arrays.copyOf(current, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}咱们由此看出，set的add办法，也是用了扩容+写时复制的办法了。
4.汇合类不平安之MAP
最初咱们来看一下map
map的线程安全类为：
Map<String,String> map = new ConcurrentHashMap<>();concurrentHashMap采纳的原理是cas，具体我会另外开一篇文章，因为很简短，就不在这儿赘述了。
总结：
并发状况下操作一个数组会出现异常，咱们大部分都会采纳加锁和写时复制进行解决。
发表回复