先看问题：
- ConcurrentHashMap是怎么做到线程安全的？
- get方法如何线程安全地获取key、value？
- put方法如何线程安全地设置key、value？
- size方法如果线程安全地获取容器容量？
- 底层数据结构扩容时如果保证线程安全？
- 初始化数据结构时如果保证线程安全？
volatile变量（sizeCtl）：它是一个标记位，用来告诉其他线程这个坑位 有没有人在，其线程间的可见性由volatile保证。
CAS操作：CAS操作保证了设置sizeCtl标记位的原子性，保证了只有一个线程能设置成功- ConcurrentHashMap并发效率是如何提高的？
- 和加锁相比较，为什么它比HashTable效率高？
//node的定义
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
// volatile 关键字修饰
volatile V val;
volatile Node<K,V> next;
public V put(K key, V value) {
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
//key 或 value都不能为空
//这是因为当通过 get(k) 获取对应的 value 时，如果获取到的是 null 时，无法判断，它是 put(k,v) 的时候 value 为 null，还是这个 key 从来没有添加。
//**1.这个key从来没有在map中映射过。
//**2.这个key的value在设置的时候，就是null。
//在非线程安全的map集合(HashMap)中可以使用map.contains(key)方法来判断，而ConcurrentHashMap却不可以。hashmap正确使用场景是单线程下，由于是单线程，当得到的value是null的时候，可以用hashMap.containsKey(key)方法来区分上面说的两重含义（保证在单线程下 线程安全 不存在并发场景，所以不会存在二义性）。
if (key == null || value == null) throw new NullPointerException();
//获取hashcode
int hash = spread(key.hashCode());
int binCount = 0;
//遍历数组中的node
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
//Node数组为空，初始化Node数组
if (tab == null || (n = tab.length) == 0)
//看下面有详细解释
tab = initTable();
//该node节点中没有元素，CAS对该位置的节点进行原子操作
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
//插入成功，退出循环
break; // no lock when adding to empty bin
}
//如果Node的hash值等于-1,map进行扩容
else if ((fh = f.hash) == MOVED)
//帮助扩容
tab = helpTransfer(tab, f);
else {
V oldVal = null;
//锁的是数组槽里面的node
synchronized (f) {
//二次确认此Node对象还是原来的那一个
//其使用Unsafe类volatile的操作volatile式地查看值，保证每次获取到的值都是最新的：
if (tabAt(tab, i) == f) {
//为什么大于等于0是代表的链表，小于0代表是红黑树？
//定义的常量 static final int TREEBIN = -2; // hash for roots of trees
//构造函数里面调用super，会将-2作为hash
//感觉没必要，直接像hashMap一样先判断是否红黑树，然后else里面处理链表逻辑
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
//这个if是判断在链表上是否存在key相同，若相同，则根据onlyIfAbsent的结果考虑是否进行替换
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
//感觉没必要申明这个对象，下面直接用e.next.next就可以了
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;
}
}
}
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
// 初始化数组
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
//sizeCtl是一个标记位，若为-1也就是小于0，代表有线程在进行初始化工作了
if ((sc = sizeCtl) < 0)
//让出CPU时间片
Thread.yield(); // lost initialization race; just spin
//CAS操作，将本实例的sizeCtl变量设置为-1，类似上个乐观锁，让别人知道我在开始初始化数组了
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
//再检查一遍数组是否为空
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
//Node数组
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
//通过位运算，n减去n二进制右移2位，相当于乘以0.75
//例如16经过运算为12，与乘0.75一样，只不过位运算更快
sc = n - (n >>> 2);
}
} finally {
//将计算后的sc（12）直接赋值给sizeCtl，表示达到12长度就扩容
//由于这里只会有一个线程在执行，直接赋值即可，没有线程安全问题
//只需要保证可见性
sizeCtl = sc;
}
break;
}
}
return tab;
}
网友评论