在前面篇文章我们分析了Hashmap在jdk1.7和1.8中put和get源码的实现原理，通过这部分源码的分析，我们了解到HashMap中的put()方法并不是线程安全的，因为不管是在添加数据还是扩容的时候由于没有锁机制的保证，容易造成数据的混乱，这也是为什么在多线程的情况下推荐使用ConcurrentHashMap的原因，因为不管是在jdk1.7亦或是在jdk1.8中都使用了锁机制，当然也有人说HashTable也提供了线程安全为什么不用呢，我们从HashTable的源码可以看出，它使用的是synchronized关键字进行加锁的，而且它锁的是整个table，但是table却只有一个，这样就导致了了HashTable的性能低下，所以在多线程的情况下官方也是推荐使用ConcurrentHashMap的，因为它与HashMap一样使用了数组+链表的方式来实现，下面我们就看下ConcurrentHashMap在jdk1.7中的put实现。
在使用put方法之前，我们得了解下ConcurrentHashMap的初始化，它提供了如图所示的几个构造方法
在代码实现中可以了解到最终所有的方法都会调用到有3个参数的构造方法，看下这个方法的实现
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) //参数检查
throw new IllegalArgumentException();
// ConcurrentcyLevel实际上就是最大并发数
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// Find power-of-two sizes best matching arguments
int sshift = 0;
int ssize = 1;
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// create segments and segments[0]
// 创建一个包含容量为cap的HashEntry数组的segment
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
// 创建一个segment数组
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
// 将s0设置为ss的第一个元素
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss; //将ss作为segments
}在这个构造函数中，经过一些初始化方法它会去创建一个Segment对象，然后在创建一个Segment数组，数组的大小就是根据传入的concurrencyLevel并发级别来的，大小是通过2的n次方计算的，因此定义concurrencyLevel的时候也最好定义为2的n次方，最后通过Unsafe的方法putOrderedObject()将Segment对象作为基础对象放入Segment数组中。在定义Segment对象的时候，通过代码我们可以了解到它继承了ReentrantLock可重入锁，因此可以看出Segment对象是线程安全的对象，在构造函数中又定义了一个HashEntry数组，这个HashEntry对象基本上和我们在HashMap中介绍的一样，同时也是一个链表结构
static final class HashEntry<K,V> {
final int hash;
final K key;
volatile V value;
volatile HashEntry<K,V> next;
HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
........
}从上面2个代码片段我们可以认识到在ConcurrentHash是一个Segment数组，而Segment对象又是一个HashEntry数组，并且Segment对象还是一个ReentrantLock的子对象，从而保证了线程的安全性，从这整个实现来看ConcurrentHashMap就是一个可以在多个Segment上面并发执行的"HashTable"，接下来了解下put(K key,V value)的实现
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
// 计算Hash值
int hash = hash(key);
// 计算下标j
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
// 若j偏移指定值处有segment就返回，若没有就创建并返回
s = ensureSegment(j);
// 将值put到segment中去
return s.put(key, hash, value, false);
}首先它会对传入的key进行一个hash值的计算并且通过位操作进行下标j的获取，然后检查在Segment数组中是否在下标j偏移处已经有值存在，如果存在，则直接进行put操作，如果不存在，则进行一些确认以及创建工作
private Segment<K,V> ensureSegment(int k) {
final Segment<K,V>[] ss = this.segments;
// 获取下标k处的offset偏移量
long u = (k << SSHIFT) + SBASE; // raw offset
Segment<K,V> seg;
// 如果下标k偏移处没有元素
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
// 使用位置0处的值
Segment<K,V> proto = ss[0]; // use segment 0 as prototype
// 根据proto 获得 segment的HashEntry容量大小
int cap = proto.table.length;
float lf = proto.loadFactor; //。。。
// 计算threshold阈值
int threshold = (int)(cap * lf);
// 创建新的HashEntry数组
HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) { // recheck
// 如果下标k处仍然没有元素，创建segment
Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
// 若下标k偏移处仍然没有segment元素，自旋
while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) {
// 若通过CAS更新成功，则退出
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
break;
}
}
}
return seg;
}在ensureSegment()方法方法中，我们也会先进行一次Segment数组中j偏移处是否有值的判断，在没有值的情况下首先创建一个HashEntry数组，数组值的一些初始信息通过获取Segment数组中位置0的初始对象进行赋值，然后再次进行Segment数组中j偏移处是否有值的判断，如果还是没有值，则创建Segment对象，最后通过while循环判断在Segment数组中j偏移处没有值的情况下进行CAS操作，如果操作成功，则直接退出，那么至此就完成了Segment对象的创建。
下面看下Segment对象的put方法
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
/*
如果tryLock成功，就返回null，
否则尝试去获取锁，同时在获取锁失败的情况下为了节约时间提前去新建或获取HashEntry,
如果超过一定次数就强制加锁
*/
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
// 根据table数组的长度 和 hash值计算index下标
int index = (tab.length - 1) & hash;
// 找到table数组在 index偏移处链表的头部
HashEntry<K,V> first = entryAt(tab, index);
// 从first开始遍历链表
for (HashEntry<K,V> e = first;;) {
// 若e!=null
if (e != null) {
K k;
// 如果key相同
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
// 获取旧值
oldValue = e.value;
// 若absent=false即允许覆盖
if (!onlyIfAbsent) {
// 覆盖旧值
e.value = value;
++modCount;
}
// 若已经找到，就退出链表遍历
break;
}
// 若key不相同，继续遍历
e = e.next;
}
else { // 直到链表尾部也没有找到相同的key
if (node != null)
// 将元素放到链表头部
node.setNext(first);
else
// 创建新的Entry
node = new HashEntry<K,V>(hash, key, value, first);
// count 用来记录元素个数
int c = count + 1;
// 如果hashmap元素个数超过threshold，并且table长度小于最大容量
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
/*
rehash跟HashMap中的resize功能差不多,将table的长度扩容为原来的两倍，
重新打包entries，并将给定的node添加到新的table
*/
rehash(node);
else // 如果没有超过阈值
// 就在index偏移处添加链表节点
setEntryAt(tab, index, node);
// 修改操作数
++modCount;
// 将count+1
count = c;
oldValue = null;
break;
}
}
} finally {
// 执行完操作后，释放锁
unlock();
}
// 返回oldValue
return oldValue;
}在该段代码中，首先初始化一个HashEntry对象node并进行了尝试加锁，加锁成功则直接进行后面的操作，如果不成功调用scanAndLockForPut()进行不断的尝试加锁
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
// 根据hash值获取指定hash偏移处的HashEntry
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
HashEntry<K,V> node = null;
int retries = -1; // negative while locating node
// 尝试获取锁失败
while (!tryLock()) {
HashEntry<K,V> f; // to recheck first below
if (retries < 0) {
if (e == null) {
// 如果hash值偏移出没有值，则新建
if (node == null) // speculatively create node
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
// 有值直接判断是否是相同的key
else if (key.equals(e.key))
retries = 0;
else
// 取获取到的HashEntry的next值，然后循环
e = e.next;
}
// 如果重取次数大于最大循环次数，则直接锁定并退出，同时也没有获取到HashEntry
else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
}
// 如果segment数据已经发生变化，重新循环取值
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}在scanAndLockForPut()方法中它会不断的进行一些尝试加锁的操作，在失败的情况下它会去判断在该Segment中判断是否存在当前key，如果没有取得，则新建一个HashEntry，如果尝试加锁的次数超过了最大的循环次数，则直接强制加锁，并退出，如果Segment中的数据发生改变，则重新循环取值。
我们再回到put()方法看下，在进行尝试加锁操作后，通过Segment的table数组长度和当前key的hash值进行位操作获取下标index，获取到index值first后进行自旋循环，如果在index处有值，则判断是否与当前的key值相同，相同且在可以覆盖old值的情况下，则用value替换old值，然后跳出当前的自旋循环，如果不相同，则通过链表的方式一直循环直到没有找到相同的key，在没有相同的key的情况下，判断node节点的情况，并且使first节点成为当前node节点的next值；判断当前table中元素的个数是否超过阈值并且table的长度是否小于允许的最大值，在满足超过阈值和小于允许的最大值的情况下，则对table进行扩容操作，扩容的同时进行数据位置的重新调整，否则就直接在table的index偏移处添加当前node为first节点，同时记录当前的table中元素个数，操作完这些后在finally中释放锁，返回当前key的old值，上面基本上就是ConcurrentHashMap的put()方法在jdk1.7中的实现，接下来看下在jdk1.8中的put的实现。
同样的，通过jdk1.8的代码可以看到ConcurrentHashMap的构造方法并没有像1.7中那样，最后都会统一调用3个参数的构造函数，而通过put()方法对应的putVal()方法如下所示
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// 计算hash值
int hash = spread(key.hashCode());
int binCount = 0;
// 自旋
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 如果table没有初始化
if (tab == null || (n = tab.length) == 0) //table==null || table.length==0
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // 若下标i偏移处的元素为null
// 直接用CAS操作i偏移处的元素，table中位置为i处元素为空的时候，不需要加锁
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)
// 若下标 i 偏移处的元素不为null，且f.hash==MOVED MOVED为常量值-1，说明正在准备扩容
tab = helpTransfer(tab, f);
else { // 如果是一般的节点
V oldVal = null;
synchronized (f) {
// 当头部元素不为null，且不需要转换成树时，需要进行同步操作
if (tabAt(tab, i) == f) {
// 若链表头部hash值 >=0
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 如果key相同
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;
// 如果链表遍历完成，还没退出，说明没有相同的key存在，在尾部添加节点
if ((e = e.next) == null){
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
else if (f instanceof TreeBin) { // 如果f是Tree的节点
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则进行红黑树的转变
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 进行是否需要进行扩容操作的判断根据当前Node中的数据个数
addCount(1L, binCount);
return null;
}在table为空的情况下，先通过initTable()方法初始化table，table是一个Node数组，与1.8中的HashMap基本一样，结构是
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
......
}先看下是如何initTable的
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
// 线程让步，让其他线程优先执行
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// 当前ConcurrentHashMap指定偏移位置处值就是SIZECTL
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];
// 将nt赋值给table
table = tab = nt;
// 计算阈值大小
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}它是首先判断table是否为空的，如果为空则不断循环，然后判断是否已经有其他线程正在初始化table了，如果有则先挂起，否则进行CAS操作，如果操作成功，则初始化Node数组，默认容量大小为16，同时计算阈值，默认为12，通过上面的步骤就完成了table的初始化，我们也可以看到在这里就完成了容量大小和阈值大小的计算。
在table不为空的情况下，如果在table下标i的偏移处不存在值，则通过CAS的方式进行直接在下标i偏移处进行值更新，更新成功则直接退出；如果下标i的偏移处不为空，且hash值为常量值-1，说明正在准备扩容，则可以通过helpTransfer()方法帮忙进行table的扩容操作；否则先进行synchronized加锁操作，判断当前table位置i偏移处的值是否还是前面判断时的值，如果是的，则再判断该处的hash值是否大于等于0，如果是的则通过链表的方式循环当前i偏移处的是否有与当前key相同的值，有相同的值则在允许覆盖当前old值的情况下，覆盖掉old值，没有相同的值则新建一个Node值放在链表最后面，如果当前hash小于0并且当前的Node节点为树节点，则进行树节点的相关操作，同时在循环链表的时候也计算当前链表中Node节点的个数binCount，做完以上操作后就退出synchronized锁；在binCount有值并且table的i偏移处的当前Node节点链表的长度超过了8，那么就对当前Node节点链表进行红黑树的转换；最后根据当前获取到的binCount值，通过addCount()方法进行整体判断是否需要进行扩容操作，经过上面一系列操作就完成了key-value的插入操作。
看完了put()方法，我们了解下get(Object key)方法，1.7中如下
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}它首先根据key的hash值通过位运算以及基础偏移量的相加获取具体的key偏移量u，然后通过偏移量u去Segment数组中获取u位置处的Segment对象，在有对象的情况下，通过for循环链表的方式获取Segment对象的HashEntry值进行key比较，如果存在则返回对应value值，否则返回null值表示不存在。
在看下get(Object key)在1.8中的实现
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;
}它首先对key进行hash值取值，然后判断在table中的hash值计算偏移量后的位置是否有值，有值则首先判断当前偏移处的hash值是否与传入的key的hash值相同，相同则判断当前key是否就是传入的key，如果是则直接取值返回，否则则判断当前的偏移处的hash值是否小于0，小于0说明正在扩容，则通过find()方法循环判断获取key对应的value值，如果大于0则通过链表的方式while循环当前偏移处的Node对象，知道获取到有相同的key值或者链表结束，有获取到值则直接返回，否则返回null表示不存在。
现在我们总结下ConcurrentHashMap在jdk1.7和1.8中的相同与不同：
1.ConcurrentHashMap在1.7中是HashEntry的Segment数组，1.8中是Node形式的Node节点；
2.1.7中Segment对象继承了ReetrantLock可重入锁类，1.8中直接使用的是CAS操作，他们都实现了安全性以及分段锁；
3.1.7中每个Segment对象可以进行扩容，1.8中当一个偏移处的Node节点数量超过8时会转换为红黑树，然后根据Node 数组中所以节点数来判断是否需要进行扩容操作；
4.1.7中的Segment对象的新HashEntry是放在表头的，而1.8中的Node节点是放在末尾的；
5.1.7中所有的ConcurrentHashMap对象的创建都会经过3个参数的构造函数进行初始化，1.8则是在put()方法中在table 为空时通过initTable()方法进行初始化的；
6.无论是在1.7还是在1.8中都是通过数组+链表的方式实现的。
1333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
