我们常用的的java.util下的比如Arraylist、HashMap、HashSet虽然线程不安全,但执行效率很高,HashTable、Vector虽然线程安全(基于synchronized锁控机制),但性能很低,而juc(java.util.concurrent)下的集合却可以保证既安全有高效,如:
ArrayList对应的高并发类是CopyOnWriteArrayList,
HashSet对应的高并发类是 CopyOnWriteArraySet,
HashMap对应的高并发类是ConcurrentHashMap。
下面通过源码看一下他们的实现原理:
1.CopyOnWriteArrayList其中的add方法:
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);//copy了旧数组,并将数组长度增加一
newElements[len] = e;//将e添加到新数组中
setArray(newElements);//将修改后的数据替换原有的数据
return true;
} finally {
lock.unlock();
}
}
可以看到当执行写操作时,先copy一份原有数据数组,再对复制数据进行写入操作,最后将复制数据替换原有数据,从而保证写操作不影响读操作。
同时,其复制的整个过程是上了锁的,所以不会产生多线程安全问题。
而加的锁ReentrantLock 相比Syncchronized具有以下功能:
- 等待可终止:
如果一个线程长期占有锁对象不释放,那么等待的线程可以选择停止等待,这样也避免了死锁的发生; - 公平锁:等待的线程必须按照申请的时间顺序去持有锁对象
- 并不像synchronized那样要么唤醒一个线程,要么唤醒所有线程
,实现了可以分组唤醒需要唤醒的线程
2.CopyOnWriteArraySet与CopyOnWriteArrayList类似,只不过前面的数据无序,不可重复
3.ConcurrentHashMap其中的put方法:
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
//和hashMap不同的是,concurrentHashMap的key和value都不允许为null
//concurrenthashmap它们是用于多线程的,并发的 ,如果map.get(key)得到了null,
// 不能判断到底是映射的value是null,还是因为没有找到对应的key而为空,
// 而用于单线程状态的hashmap却可以用containKey(key) 去判断到底是否包含了这个null。
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
//如果是第一次put,进行初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
//根据(tab.length - 1) & hash 计算目标节点在数组中的位置
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//如果为空,则通过cas 添加一个新建一个头节点
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//hash为-1 说明是一个forwarding nodes节点,表明正在扩容
else if ((fh = f.hash) == MOVED)
//帮助扩容
tab = helpTransfer(tab, f);
else {
V oldVal = null;
//对上面计算出来的节点进行加锁
synchronized (f) {
//这里判断下有没有线程对数组进行了修改
if (tabAt(tab, i) == f) {
//这里如果hash值是大于等于0的说明是链表
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
//如果找到了目标节点,那么进行值替换
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
//如果循环到链表结尾还没发现,那么进行插入操作
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
//如果是树
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
//如果链表数量大于TREEIFY_THRESHOLD(8),开始执行转换树
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
//进行元素数量统计,和决定是否扩容
addCount(1L, binCount);
return null;
}
这里主要应用了锁分段的技术:
将数据分成一段一段的存储,然后给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据的时候,其他段的数据也能被其他线程访问,put方法中首先就是通过算法找到负责这段数据的分段锁,
简而言之:JUC下的集合采用了读取操作时不加锁,而在修改数据时:
CopyOnWriteArrayList使用ReentrantLock这种互斥锁的特性(1.等待停止、2.公平锁、3.分组唤醒)避免了线程进入阻塞状态,从而达到高效
ConcurrentHashMap使用锁分段技术保证了数据的安全且高效;