集合类线程安全吗？ConcurrentModification异常遇到过吗？如何解决？
集合类不安全的问题
1. ArrayList的线程不安全问题
1.1 首先回顾ArrayList底层
- ArrayList的底层数据结构是数组
- 底层是一个
Object[] elementData的数组，初始化默认为空数组 - 默认容量
DEFAULT_CAPACITY为10，如果容量不够调用grow()方法，将容量调整为原来的1.5倍，核心代码为int newCapacity = oldCapacity + (oldCapacity >> 1); - 扩容过程是首先创建出来一个新数组，之后使用
Arrays.copyOf(elementData, newCapacity)将原数组内容拷贝到新数组
回到本节知识，
1.2 为什么说ArrayList会存在线程不安全问题？
很简单的一个示例代码：
package com.yuxue.juc.collection;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
public class ArrayListDemo {
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,5));
System.out.println(list);
},"Thread"+ i).start();
}
}
}
此时程序会报异常：
出现了一个java.util.ConcurrentModificationException异常！
为什么会出现这样的结果？首先我们都知道，在调用ArrayList时，底层add方法是没有加synchronized即没有加锁的，当不同的线程调用方法时，会出现不安全的问题
1.3 为什么会出现这种问题？
并发修改这个list所导致的
一个线程正在写入，另一个线程来抢夺，导致数据不一致，并发修改异常
1.4 解决方案？
1.4.1 Vector
- Vector底层加了锁，加锁数据一致性一定可以保证，但是并发性急剧下降！
- ArrayList就是牺牲线程安全性才提出的
- 但是Vector是在JDK1.0已经出现的，ArrayList在JDK1.2版本出现的
- 所以用Vector可以但是效率太低，那么有没有其他的工具类可以满足?
1.4.2 synchronizedList
将代码改为以下的代码即可
List<String> list = Collections.synchronizedList(new ArrayList<>());
1.4.3 CopyOnWriteArrayList
List<String> list = new CopyOnWriteArrayList<>();//写时复制，读写分离
CopyOnWriteArrayList.add方法:
public boolean add(E e) {
final ReentrantLock lock = this.lock;
//加锁
lock.lock();
try {
//获取原来的数组，保存副本为elements
Object[] elements = getArray();
//获取原数组长度
int len = elements.length;
//将其拷贝到新数组newElements，长度为原数组加1
Object[] newElements = Arrays.copyOf(elements, len + 1);
//第len上元素为新添加值e
newElements[len] = e;
//设置新数组为newElements
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
CopyOnWrite容器即写时复制（一种读写分离的思想），往一个元素添加容器的时候，不直接往当前容器Object[]添加，而是先将当前容器 Object[]进行copy，复制出一个新的容器Object[] newElements，让后新的容器添加元素，添加完元素之后，再将原 容器的引用指向新的容器setArray(newElements),这样做可以对CopyOnWrite容器进行并发的读，而不需要加锁， 因为当前容器不会添加任何元素，所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器
2. Set的线程不安全问题
HashSet线程不安全，同样报错为java.util.ConcurrentModificationException异常！
解决的类或者方法：
Set<String> set = Collections.synchronizedSet(new HashSet<>());Set<String> set = new CopyOnWriteArraySet<>();
其底层还是CopyOnWriteArrayList，因为其源码为：
public CopyOnWriteArraySet() {
al = new CopyOnWriteArrayList<E>();
}
HashSet的底层是HashMap！
/**
* Constructs a new, empty set; the backing HashMap instance has
* default initial capacity (16) and load factor (0.75).
*/
public HashSet() {
map = new HashMap<>();
}
初始容量为16，默认负载因子为0.75的标准的HashMap！
其中底层还有一个很重要的问题，当HashSet调用add(e)方法是，如果是HashMap，其Key为e，value值为什么？此时通过源码我们可以得到：
public boolean add(E e) {
//key为e,value为PRESENT
return map.put(e, PRESENT)==null;
}
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
3. Map的线程不安全问题
HashMap是线程不安全的，想解决可以用
- Hashtable
- ConcurrentHashMap
- Collections.synchronizedMap
3.1 HashMap和Hashtable区别？
HashMap和Hashtable都实现了Map接口，但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有：线程安全性，同步(synchronization)，以及速度
- HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受null(HashMap可以接受为null的键值(key)和值(value)，而Hashtable则不行)
- HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好
- 另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别
- 由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
- HashMap不能保证随着时间的推移Map中的元素次序是不变的
3.2HashMap与ConcurrentHashMap区别？
准备回头写一篇博客专门总结，先留着 : )
