ConcurrentHashMap
我们都知道HashMap不是线程安全的，所以在处理并发的时候会出现问题。
而HashTable虽然是线程安全的，但是是通过整个来加锁的方式，当一个线程在写操作的时候，另外的线程则不能进行读写。效率其实是很低的。
所以ConcurrentHashMap出现了，它则可以支持并发的读写。跟1.7版本相比，1.8版本又有了很大的变化，已经抛弃了Segment的概念，虽然源码里面还保留了，也只是为了兼容性的考虑。
1.ConcurrentHashMap声明
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements
ConcurrentMap<K,V>, Serializable {}
ConcurrentHashMap同样也继承了AbstractMap，但是实现的是ConcurrentMap和Serializable。
2.ConcurrentHashMap构造方法
//空构造
public ConcurrentHashMap() {
}
//指定容量的构造方法，并赋值给sizeCtl
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
//volatile所有线程可见的初始化容量大小
private transient volatile int sizeCtl;
private static final int tableSizeFor(int c) {
int n = c - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
//给定一个map数据的构造方法，默认容量16
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
//给定负载因子的构造方法
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
//给定map大小，加载因子以及并发度（预计同时操作数据的线程）
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // Use at least as many bins
initialCapacity = concurrencyLevel; // as estimated threads
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
上述为ConcurrentHashMap的构造方法，额可以看到和hashMap大同小异，多了一个并发度的构造方法。
3.put(K key, V value)
// 单纯的额调用putVal方法，并且putVal的第三个参数设置为false, 当设置为false的时候表示
这个value一定会设置 , true的时候，只有当这个key的value为空的时候才会设置
public V put(K key, V value) {
return putVal(key, value, false);
}
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
private static final sun.misc.Unsafe U;
//初始化table
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
//第一次put的时候，table还没被初始化，进入while
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
//sizeCtl初始值为0，当小于0的时候表示在别的线程在初始化表或扩展表，使线程由执行状态进入就绪状态
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) {
//初始化数组,长度为16,或者初始化在构造ConcurentHashMap的时候传入的参数
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
//将这个数组赋值给table
table = tab = nt;
//计算下次扩容的大小,实际就是当前容量的0.75倍,这里使用了右移来计算
sc = n - (n >>> 2);
}
} finally {
//设置sizeCtl为sc,如果默认是16的话,那么此时sc = 16*0.75=12
sizeCtl = sc;
}
break;
}
}
return tab;
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
//K,V都不能为空，否则的话跑出异常，和hashTable一样
if (key == null || value == null) throw new NullPointerException();
//计算key的hash值
int hash = spread(key.hashCode());
int binCount = 0;
//死循环
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
//如果table为null或者长度为0
if (tab == null || (n = tab.length) == 0)
//初始化table
tab = initTable();
//i=(n-1)&hash 等价于i=hash%n(前提是n为2的幂次方).即取出table中位置的节点用f表示。
//有如下两种情况：
//如果table[i]==null(即该位置的节点为空，没有发生碰撞)，则利用CAS操作直接存储在该位置，如果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
}
//检查table[i]的节点的hash是否等于MOVED，如果等于，则检测到正在扩容。
else if ((fh = f.hash) == MOVED)
//帮助扩容
tab = helpTransfer(tab, f);
//运行到这里，说明table[i]的节点的hash值不等于MOVED
else {
V oldVal = null
//同步锁
synchronized (f) {
//避免多线程，需要重新检查
if (tabAt(tab, i) == f) {
//链表节点
if (fh >= 0) {
binCount = 1;
//下面的代码就是先查找链表中是否出现了此key，如果出现，则更新value，并跳出循环，
//否则将节点加入到列表末尾并跳出循环
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;
//仅putIfAbsent()方法中onlyIfAbsent为true
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;
}
}
}
}
if (binCount != 0) {
// 插入成功后，如果插入的是链表节点，则要判断下该桶位是否要转化为树if (binCount != 0) {
// 实则是 > 8,执行else,说明该桶位本就有Node
if (binCount >= TREEIFY_THRESHOLD)
//若length<64,直接tryPresize,两倍table.length;不转树 if (oldVal != null)
//这里是为了避免table 过小的时候就进行转换成树的。
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
//帮助扩容
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// 如果 table 不是空 且 node 节点是转移类型，数据检验
// 且 node 节点的 nextTable（新 table） 不是空，同样也是数据校验
// 尝试帮助扩容
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// 根据 length 得到一个标识符号
int rs = resizeStamp(tab.length);
// 如果 nextTab 没有被并发修改 且 tab 也没有被并发修改
// 且 sizeCtl < 0 （说明还在扩容）
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
// 如果 sizeCtl 无符号右移 16 不等于 rs （ sc前 16 位如果不等于标识符，则标识符变化了）
// 或者 sizeCtl == rs + 1 （扩容结束了，不再有线程进行扩容）（默认第一个线程设置 sc ==rs 左移 16 位 + 2，当第一个线程结束扩容了，就会将 sc 减一。这个时候，sc 就等于 rs + 1）
// 或者 sizeCtl == rs + 65535 （如果达到最大帮助线程的数量，即 65535）
// 或者转移下标正在调整 （扩容结束）
// 结束循环，返回 table
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
// 如果以上都不是, 将 sizeCtl + 1, （表示增加了一个线程帮助其扩容）
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
// 进行扩容转移
transfer(tab, nextTab);
// 结束循环
break;
}
}
return nextTab;
}
return table;
}
该方法和HashMap 的高度相似，但是多了很多同步操作。
- 校验key value 值，都不能是null。这点和 HashMap 不同。
- 得到 key 的 hash 值。
- 死循环并更新 tab 变量的值。
- 如果容器没有初始化，则初始化。调用 initTable 方法。该方法通过一个变量 + CAS 来控制并发。cas操作这里就不在分析，我自己也只是了解，没有深入的学习，有兴趣的可以深入了解。
- 根据 hash 值找到数组下标，如果对应的位置为空，就创建一个 Node 对象用CAS方式添加到容器。并跳出循环。
- 如果 hash 冲突，也就是对应的位置不为 null，则判断该槽是否被扩容了（-1 表示被扩容了），如果被扩容了，返回新的数组。
- 如果 hash 冲突 且 hash 值不是 -1，表示没有被扩容。则进行链表操作或者红黑树操作，注意，这里的 f 头节点被锁住了，保证了同时只有一个线程修改链表。防止出现链表成环，保证了同步。
- 和 HashMap 一样，如果链表树超过8，则修改链表为红黑树。
- 将数组加1（CAS方式），如果需要扩容，则调用 transfer 方法进行移动和重新散列。
4.get(Object key)
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
get方法没设么好说的，遍历取值。get操作全程不需要加锁是因为Node的成员val是用volatile修饰的。保证了多线程下的修改所有线程可见。
5.ConcurrentHashMap的同步机制
这里我想说一下，这篇文章对于源码我只是大概的学习了下，并没有深入的了解cas操作等。 平时使用的时候其实也不用了解的很详细，毕竟这个东西不是一两天能够清楚。但是我们首先第一步，也是最重要的一步了解它的同步机制与原理。
- 1.7的分段锁机制
ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁（ReentrantLock），在ConcurrentHashMap里扮演锁的角色；HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组。Segment的结构和HashMap类似，是一种数组和链表结构。一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得与它对应的Segment锁。
ConcurrentHashMap初始化时，计算出Segment数组的大小ssize和每个Segment中HashEntry数组的大小cap，并初始化Segment数组的第一个元素；其中ssize大小为2的幂次方，默认为16，cap大小也是2的幂次方，最小值为2，最终结果根据根据初始化容量initialCapacity进行计算，其中Segment在实现上继承了ReentrantLock，这样就自带了锁的功能。
当执行put方法插入数据时，根据key的hash值，在Segment数组中找到相应的位置，如果相应位置的Segment还未初始化，则通过CAS进行赋值，接着执行Segment对象的put方法通过加锁机制插入数据。
1、线程A执行tryLock()方法成功获取锁，则把HashEntry对象插入到相应的位置；
2、线程B获取锁失败，则执行scanAndLockForPut()方法，在scanAndLockForPut方法中，会通过自旋重复执行tryLock()方法尝试获取锁，在多处理器环境下，重复次数为64，单处理器重复次数为1，当执行tryLock()方法的次数超过上限时，则执行lock()方法挂起线程B；
3、当线程A执行完插入操作时，会通过unlock()方法释放锁，接着唤醒线程B继续执行； - 1.8元素node上锁
取消了Segment分段锁的数据结构，取而代之的是数组+链表（红黑树）的结构。而对于锁的粒度，调整为对每个数组元素加锁（Node）。
1、在ConcurrentHashMap1.8中，同步处理主要是通过Synchronized和unsafe两种方式来完成的。
2、在取得sizeCtl、某个位置的Node的时候，使用的都是unsafe的方法，来达到并发安全的目的
3、当需要在某个位置设置节点的时候，则会通过Synchronized的同步机制来锁定该位置的节点
4、在数组扩容的时候，则通过处理的步长和fwd节点来达到并发安全的目的，通过设置hash值为MOVED
5、当把某个位置的节点复制到扩张后的table的时候，也通过Synchronized的同步机制来保证现程安全。
总结
对于ConcurrentHashMap的学习，只是学习了一些基本设计思想和原理，没有深入学习。有不对的地方欢迎大家指出，大家一起学习，一起探讨。关于源码的文章暂时就更新到这，后续可能会先学习一些其他的东西，在这里记录下来，主要是做一些随笔，后续用到的时候好回来继续学习。
