HashMap和CurrentHashMap有关的位移操作
1、HashMap
HashMap中获取根据传入的key获取元素位置的时候，会先获取key的hash值（用key的hashCode异或上key右移16位的二进制值），再将获取到的hash值与table.lenth-1相与，即可获得key元素在table的位置
static final int hash(Object key){
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16)
}
目的是为了让key的hash值得高16位也参与计算
2、CurrentHashMap
JDK1.8中，对给定的初始化大小，用它本身加上它右移两位的值再加上1的值，再去获取一个2的整次幂的数
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
// 用它本身加上它右移两位的值再加上1的值，再去获取一个2的整次幂的数
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
JDK1.8中，对于sizeCtl的值为-N时，取对应的二进制的低16位数值为M，代表此时有M-1个扩容线程。而并不代表有N-1个线程
CurrentHashMap
JDK1.7
1、思想
ConcurrentHashMap将数据分成一段一段地存储，然后给每一段数据配一把锁，当一个线程占用的锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问
2、结构
CurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁，在CurrentHashMap里扮演锁的角色；HashEntry则用于存储键值对数据。一个CurrentHashMap里包含一个Segment数组。Segment的结构和HashMap类似，是一种数组和链表结构。一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得与他对应的Segment锁。
3、初始化segment
3.1初始化segment数组
segment数组的长度是ssize通过concurrencyLevel（并发等级）计算得出的。为了能够通过按位与的散列算法定位segment数组的索引，必须保证segment数组的长度是2的N次方，所以必须计算出一个大于或等于concurrencyLevel的最小的2的N次方的值所谓segment数组的长度。
3.2初始化segmentShift和segmentMask
segmentShift和segmentMask这两个变量需要在定位segment数组时的散列算法里使用。
3.3初始化每个segment
由于每个segment里面是HashEntry数组，所以这一步也就是初始化HashEntry。构造函数中initialCapacity就是HashEntry数组的初始长度。
4、定位segment
既然ConcurrentHashMap是使用分段锁segment来保护不同的数据，那么在插入和获取元素的时候，必须先通过散列算法定位到segment。ConcurrentHashMap会首先使用Wang/Jenkins hash额变种算法对元素进行一次再散列，目的是减少散列冲突。
5、ConcurrentHashMap的操作
5.1get操作
segment的get操作非常简单和高效，只需要通过一次再散列就可以定位到HashEntry，再通过一次散列就可以找到对应的元素。
get操作的高效之处在于整个get过程不需要加锁，除非读取到的值是空值才会加锁重读。它是如何做到的呢？原因是它的get方法里将要使用的共享变量都定义成了volatile类型，保证了线程之间的可见性，还能够被多线程同时读，并且保证不会读到过期的值（之所以不会读取到过期的值是因为基于Java内存模型的happen before原则，对volatile字段的写操作先于读操作，所以即使两个线程同时修改和获取volatile变量，get操作也能拿到最新的值）
5.2put操作
由于put操作需要对共享变量进行写入操作，所以为了线程安全，在操作共享变量时，必须加锁。put方法首先定位到segment，然后在segment进行插入操作，插入操作需要经过两个步骤：第一步是判断是否需要对HashEntry扩容，第二步是定位添加元素的位置，然后将其放在HashEntry数组里。
（1）是否需要扩容
在插入元素前会判断segment里的HashEntry是否超过阈值，如果超过阈值，则先进行扩容。值得一提的是，segment的扩容比HashMap更恰当，因为HashMap是在插入元素之后判断是否需要扩容，如果扩容之后没有添加新元素，就进行了一次无效的扩容
（2）如何扩容
在扩容的时候，首先会创建一个容量是原来两倍的数组，然后将原数组里的元素进行再散列后插入到新的数组里。为了高效，ConcurrentHashMap不会对整个容器进行扩容，而只对某个segment扩容。
2、1.8
1、关于初始化
对给定的初始化大小，用它本身加上它右移两位的值再加上1的值，再去获取一个2的整次幂的数
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
// 用它本身加上它右移两位的值再加上1的值，再去获取一个2的整次幂的数
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
tableSizeFor方法
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;
}
2、sizeCtl含义解释
ConcurrentHashMap的构造方法中，都涉及到一个变量sizeCtl，他的值不同，对应的含义也不一样
| 值 | 含义 |
|---|---|
| 0 | 代表数组未初始化，且数组的初始容量是16 |
| 正数 | 如果数组未初始化，那么其记录的是数组的初始容量； 如果数组已经初始化，那么记录的是数组的扩容阈值 |
| -1 | 表示数组正在进行初始化 |
| -N | 取对应的二进制的低16位数值为M，代表此时有M-1个扩容线程。而并不代表有N-1个线程 |
3、初始化
第一次put操作，会先判断一下table数组为空，如果为空，则先进行table初始化，table初始化时，先判断sizeCtl的值，如果小于0则表示有其他线程正在初始化，自己就让出CPU执行权，否则就开始初始化，初始化采用cas方法方式，尝试将sizeCtl更新为-1，告知其他线程我正在初始化，下面会进行double check，确保table没有被初始化，初始化完成之后更新sizeCtl，这时候这个sizeCtl大于0，代表的是下一次需要扩容的table阈值。如果不需要初始化table，就计算key的hash值，找到对象的node，如果node为null用cas的方式插入node，如果不为null且node的hash值为-1，代表正在扩容，则加入扩容的队伍，如果没有在扩容，就加入node，注意，加入的时候对node加了sync锁，锁的就是这个node，这个过程会判断fh得值，判断插入的是连表还是红黑树。
final V putVal(K key, V value, boolean onlyIfAbsent) {
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;
if (tab == null || (n = tab.length) == 0)
// 初始化node数组
tab = initTable();
// 插入元素会先根据key的hash值取出对应的node，如果node为null，则直接加入
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
}
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
//使用sync关键字保证线程安全性，sync锁的是当前node节点，锁的粒度小了，
//就不会影响其他node节点的插入了（对比hashmap，锁的是整个数组，锁粒度太大）
synchronized (f) {
if (tabAt(tab, i) == f) {
/*
当fh大于0时，代表当前是链表，插入式循环遍历其他链表元素，如果不相等就采用尾插法插入链表
当不大于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;
}
}
}
}
if (binCount != 0) {
// 添加完之后会进行判断，如果链表长度大于8且数组长度大于64，会进行树化操作
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 这个方法做两件事：1、维护集合的长度 2、判断集合的长度是否超过了阈值，超过了就进行扩容
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，小于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<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
4、ConcurrentHashMap的操作
5、其他
5.1关于hash值
put()之前会先计算key的hash值，计算的这个值一定是一个正数，方便添加元素判断该节点的类型
int hash = spread(key.hashCode());
5.2插入元素是如何保证线程安全的
使用sync关键字保证线程安全性，sync锁的是当前node节点，锁的粒度小了，就不会影响其他node节点的插入了（对比hashmap，锁的是整个数组，锁粒度太大）
5.3关于fh（标识是链表还是红黑树）
当fh大于0时，代表当前是链表，插入式循环遍历其他链表元素，如果不相等就采用尾插法插入链表
当不大于0时，代表不是链表结构，是红黑树，新数据则插入红黑树
5.4、扩容
首先判断数组是不是空的，如果数组是空的，先去创建数组，如果数组正在被创建，则尝试对baseCount++，如果加成功，就结束，如果不成功，则进行自旋操作，直到加成功。如果数组不为空，首先判断这个位置是否有对象，没有对象则创建counterCell对象，对counterCell里面的value++，成功结束循环，如果不为空，判断是否冲突，冲突的话重新计算线程的哈希值，再从头循环，选择不同的counterCell，不冲突则尝试累加counterCell中的value
扩容表示戳计算方式？
保证在同一条件下，不同线程来了，计算出的戳是一致的
如何保证写数据的线程安全？
hash寻址算法？
先计算最小的任务量就是要迁移的数组的长度，默认为16
数组的节点值为fwd（-1）或者hashCode为MOVED，代表这个节点正在扩容并且数据正在迁移
当一个数组迁移完，那么所有位置都为fwd，则再次进行分配，去迁移其他数据
如何判断线程是否全部完成扩容了呢？
sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2
扩容完开始迁移
如果数组数组为空，直接给数组一个fwd，说明已经迁移完
迁移的时候使用到了sync，锁的也是node节点，迁移的逻辑和JDK1.7一样
130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
