首先来说，他们都是线程不安全的
一、ArrayList
public static void main(String[] args) {
// List<String> arrayList = Arrays.asList("1", "2", "3");
List<String> arrayList = new ArrayList<>();
for (int i = 0; i < 30; i++) {
new Thread(() -> {
arrayList.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(arrayList);
}).start();
}
}
运行后出现报错：java.util.ConcurrentModificationException
1.导致原因
ArrayList是线程不安全的，add方法没有加synchronized关键字，所以add方法是线程不安全的，这时候对list操作，又要写又要读就导致了线程安全问题
2.解决方案
解决方案一：ArrayList的父类是Vector，而Vector是线程安全的。看源码可以得知其add方法是加了锁的，所以是线程安全。虽然他能够保证数据一致性，但是因为只能一个写或者一个读，导致它比较慢，性能差。
public static void main(String[] args) {
List<String> list = new Vector<>();
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
}, String.valueOf(i)).start();
}
}
解决方案二：使用Collections工具类，可以将一个线程不安全的ArrayList变成线程安全的。此方案小数据量的时候比较适合，大数据链参考以下方法。
public static void main(String[] args) {
List<String> list = Collections.synchronizedList(new ArrayList<>());
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
}, String.valueOf(i)).start();
}
}
解决方案三：可以使用JUC提供的CopyOnWriteArrayList，运用读写分离的思想，既能保证数据的一致性又能高性能。写的时候先进行复制，写的其实是一份新的复印件，原件可以进行集体的读。写完了之后unlock解锁，将新的复印件替换过去。
public static void main(String[] args) {
List<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
}, String.valueOf(i)).start();
}
}
查看源码，得知add方法的源码，往一个容器中添加元素的时候，不是直接往当前容器Object[]添加，而是先将当前容器Object[]进行copy，复制出一个新的容器Object[] newElements，然后新的容器Object [] newElements中添加元素，添加元素之后，再将原容器的引用指向新的容器setArray(newElements);这样做的好处是可以对CopyWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素，所以CopyOnWrite容器也是一种读写分离得思想。
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);
return true;
} finally {
lock.unlock();
}
}
二、Set
public static void main(String[] args) {
Set<String> set = new HashSet<>();
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
set.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(set);
}, String.valueOf(i)).start();
}
}
运行后也出现报错：java.util.ConcurrentModificationException
一、解决方案同理：
//方案一：
Set<String> set = Collections.synchronizedSet(new HashSet<>());
//方案二：
Set<String> set = new CopyOnWriteArraySet<>();
二、HashSet的底层
HashSet的底层是HashMap，那为什么HashMap的put方法是两个值，而HashSet是add一个值呢，因为查看HashSet的源码可以得知，add方法实际上就是调用了HashMap的put方法，key就是add进去的值，而value永远都是一个Object类型的常量，也就是说所有HashSet的value都不重要
public HashSet() {
map = new HashMap<>();
}
三、Map
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0, 8));
System.out.println(map);
}, String.valueOf(i)).start();
}
}
运行后也出现报错：java.util.ConcurrentModificationException
一、解决方案同理：
//方案一：
Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
//方案二：
Map<String,String> map = new ConcurrentHashMap<>();
二、HashMap的底层
数组+链表+红黑树
散列表底层就是一个数组基础上做得完善，散列值通过散列函数，将key值转换成散列值存储在数组中，但是有时候会出现散列冲突的情况，也就是不同的key经过散列函数计算后生成了同一个散列值，这时候如果想要存储在数组中，发现存储空间就已经被占据了，于是采用一种链表法来解决散列冲突的问题，即在数组中存储一个“槽”，每个槽后面跟着一条链表，不同key得到相同的散列值，都存储在这条链表下，当链表长度不断的增长，直到长度到8，这条单向链表就会变成一条红黑树。
