首先来说,他们都是线程不安全的
一、ArrayList
public static void main(String[] args) {
// List arrayList = Arrays.asList("1", "2", "3");
List 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 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 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 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 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 set = Collections.synchronizedSet(new HashSet<>());
//方案二:
Set 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 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 map = Collections.synchronizedMap(new HashMap<>());
//方案二:
Map map = new ConcurrentHashMap<>();
二、HashMap的底层
数组+链表+红黑树
散列表底层就是一个数组基础上做得完善,散列值通过散列函数,将key值转换成散列值存储在数组中,但是有时候会出现散列冲突的情况,也就是不同的key经过散列函数计算后生成了同一个散列值,这时候如果想要存储在数组中,发现存储空间就已经被占据了,于是采用一种链表法来解决散列冲突的问题,即在数组中存储一个“槽”,每个槽后面跟着一条链表,不同key得到相同的散列值,都存储在这条链表下,当链表长度不断的增长,直到长度到8,这条单向链表就会变成一条红黑树。