集合类不安全的问题
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区别?
准备回头写一篇博客专门总结,先留着 : )