Author ： lss 文章若有表示错误，词不达意。请多多指教。
HashTable && ConcurrentHashMap
开始讲之前说的废话：大家都知道这是我刚开始写文章，上期的HashMap 访问量，收藏，还有反馈率。都很高，超乎的了我的想象，但就是没多少点赞，这个是什么情况呢，难道大家的点赞功能出BUG了吧。需要我在线修一嘛。哈哈，如果你觉得小编写的不错，就点个赞呗。 上期有粉丝提议我开个微信群。所以这里我也就尝试一下吧。多谢大家鼓励。后续文章陆续更新。谢谢大家。 小编把自己的微信也贴出来了，如果你也想加入这个群，或者想交流下技术。欢迎骚扰，记得备注Java或者CSDN之类关键字哦。那就开始今天的文章吧。打波小公告
前言
上期我们将了 HashMap。我想大家对 HashMap 都有所了解。 众所周知， HashMap 是一个线程不安全的容器。那么如何解决这个问题呢。当然我们可以自己对 HashMap 做一些锁机制等操作。关于锁的问题，等集合系列出完，会陆续发布关于锁的文章，希望大家可以多多支持小编。那么废话就不多说了，就引入今天的重点吧。
JDK 对于这个容器的安全问题，也给我们提供了几种解决方式。如HashTable ，ConcurrentHashMap **Collections.synchronizedMap（）。**都可以完美的解决我们 HashMap 由于线程不安全的问题。那么下来我们就一个个来介绍下吧。
HashTable
简介
HashTable 是一个线程安全的基于 Key，Value 形式存在的容器。且 key 和 value 都不允许为 null。底层也是由数组和链表构成。
构造方法
声明一点，本文中部分源码并没有像之前那样每行都加注解。因为部分源码和 HashMap 是一致的，所以相同事情不会做第二遍。 HashTable 这块小编大概列不出一样 和 HashMap 不一致的地方
Hashtable()
// 和 HashMap 不同的是 HashTable 默认的初始容量为 11
public Hashtable() {
// 请注意一下 这里 初始容量是直接在这里写死，后续会用到。
this(11, 0.75f);
}
public Hashtable(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal Load: "+loadFactor);
if (initialCapacity==0)
initialCapacity = 1;
this.loadFactor = loadFactor;
table = new Entry[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
initHashSeedAsNeeded(initialCapacity);
}
其余几种 构造方法就不做展示了，和 HashMap差不多。 最终都会调用 Hashtable 这个方法。
put
// 其实就是加了一个 synchronized 来保证线程安全
public synchronized V put(K key, V value) {
// 值不可为 Null
if (value == null) {
throw new NullPointerException();
}
Entry tab[] = table;
int hash = hash(key);
// 获取下标位置
int index = (hash & 0x7FFFFFFF) % tab.length;
// 这里就是遍历这个 table 中的元素
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
// 如果 hash值相同，且 key 也相同 新值替换旧值
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
modCount++;
if (count >= threshold) {
// 扩容 这里的扩容和 HashMap 有点不一样会放在后面解释
rehash();
tab = table;
hash = hash(key);
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
Entry<K,V> e = tab[index];
tab[index] = new Entry<>(hash, key, value, e);
// table 的长度 HashMap 中是size变量
count++;
return null;
}
get
// 也是有一个 synchronized 来保证线程安全的
public synchronized V get(Object key) {
Entry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
// 遍历这个 table 拿到与对应的值
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return e.value;
}
}
// 没有与之对应的 返回 NULL
return null;
}
remove
// 也是有一个 synchronized 来保证线程安全的
public synchronized V remove(Object key) {
Entry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
// 获取table 中的所有元素
for (Entry<K,V> e = tab[index], prev = null ; e != null ; prev = e, e = e.next) {
// 找到与之对应的数据 并删除
if ((e.hash == hash) && e.key.equals(key)) {
modCount++；
if (prev != null) {
prev.next = e.next;
} else {
tab[index] = e.next;
}
count--;
V oldValue = e.value;
e.value = null;
return oldValue;
}
}
return null;
}
扩容
protected void rehash() {
int oldCapacity = table.length;
Entry<K,V>[] oldMap = table;
// 和 HashMap 不同的是 这里不是2倍扩容 还加了一个 1
/**
* 小编也看过很多的文章还有视频，发现这里的解答也都是一塌糊涂。都没说到点子上，
* 那么小编就为大家奉献上来吧, 我们知道 HashMap 的都是2的幂次方。而且采用的是位运算
* 而 HashTable 就一样了，这里没有默认的初始容量的变量之类的，而是直接在构造方法中写死了
* 一个 11 的数值。刚此时 HashTable 还是进行的 取模操作。 你此时想想如果说，我现在扩容两倍
* 成了 22 偶数了，那么在取模操作中 奇数 出现的碰撞率是 小于 偶数的碰撞率的。所以 +1 就是为了
* 减少 碰撞。 那么我下面展示一个图看看 偶数和奇数的差距吧
*/
int newCapacity = (oldCapacity << 1) + 1;
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
Entry<K,V>[] newMap = new Entry[newCapacity];
modCount++;
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
boolean rehash = initHashSeedAsNeeded(newCapacity);
table = newMap;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
if (rehash) {
e.hash = hash(e.key);
}
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = newMap[index];
newMap[index] = e;
}
}
}
为什么不让大家说**可能具有特殊性 ** 小编特意的尝试了好多数字。
总结:
- HashTable 首先是一个线程的安全的，原因是采用了 synchronized
- 他的默认初始容量为 11 HashMap为16，他的Key Value 不为Null HashMap 可以为 Null
- 他的扩容是原来的 2倍 +1 , HashMap扩容是原来的 2 倍
好了，HashTable 就讲到这里了，因为跟 HashMap 1.7 相差不了多少。下面就就该重点介绍介绍 ConcurrentHashMap。这个里面的东西还是比较多的。
ConcurrentHashMap
简介
ConcurrentHashMap 也是一个基于key,Value 存储的容器，且key,value 不可为 Null 。它的底层 1.7 是由数组 +链表。 1.8 由数组 + 链表 + 红黑树。这样看来他的实现和 HashMap 是一样的。但是为什么它就可以保证线安全呢？ 带着这个疑问步入后续文中 下文中先说 1.7 的实现原理。再说 1.8 的实现原理。这两个版本不仅在数据结构上发生了变化。在加锁的方式上面也有了明显的变化。好了废话不多说了。直接进入正题吧。看大致看下图吧
一个Segment 就是一个分段锁，那么拥有多个分段锁的时候，就会将多个 Segment 放入一个 Segment 数组中。
segment 中有一个 HashEntry 对象也就是我们要存数据的位置。那么一个 Segment中有多少个 HashEntry 呢 这个取决与我们的构造方法。 这里大家只需要明白 segment 中 HashEntry 的数量 = 初始容量 / 最大并大量 先有个大致的了解。当然这个结果不一定百分百正确哦。包括也不会存在图中 1 对 1关系在构造方法中会有详细解析。这里就先有个宏观上的概念。 知道他是什么样子即可。
基本属性
// 默认的初始容量为 16
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 默认的负载因子为 0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 默认的并发级别为 16
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 最大的容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// segment 最小的数组容量 后续会有图文介绍
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
// 最大的分段数量
static final int MAX_SEGMENTS = 1 << 16
// 分段锁
final Segment<K,V>[] segments;
构造方法
不少小伙伴应该也大致知道。 1.7 ConcurrentHashMap 有分段锁 ，那么你知道这个分段锁是怎么实现的吗？再带着这个疑问往下面走。 我们要做到 知其然并知其所以然 。
// 默认的即为 16，0.75， 16
public ConcurrentHashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
// 最大并发量(分段数量) 不能大于 最大的分段数量
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// Find power-of-two sizes best matching arguments
int sshift = 0;
int ssize = 1;
// 计算分段锁数量，
/**
* 思考一个问题 ? 我们已经传入了一个最大并大值（分段锁），为什么还要计算？
* 假设我现在传了一个 3 的奇数数值，那我的分段锁就是 16 / 3 也就是每个
* segment下有 5个 hashEntry 那我多的那个 hashEntry 应该怎么办呢？
* 所以这里就是为了保证我们的 分段锁都是 2 的幂次。
*/
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]
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
// 通过 ssize 构建 Segment[] 数量
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
插入方法 put
ConcurrentHashMap 在插入的时候和 HashMap 是有区别的，ConcurrentHashMap 会计算两次 hash 第一次计算是为了找到是那个 Segment 第二次计算是为找锁定是那个 HashEntry。 如图所示。我要插入一个 key,Value 的数据。此时计算得到这个 Segment 在 Segment[] 下标为 1 的时候位置。紧着会在计算一次 hash，锁定了 HashEntry 的位置。然后再将值 插入进去。大致的原理就是这个样子，那我们紧接着就看下是如何操作的吧。
public V put(K key, V value) {
Segment<K,V> s;
// 值不可为 null
if (value == null)
throw new NullPointerException();
int hash = hash(key);
// 这个 j 就是为了计算出 Segment 的位置。 这就是上面说到的 segmentMask 。
int j = (hash >>> segmentShift) & segmentMask;
// 如果这个 Segment 为 null 的话就初始话这个 Segment
// 在构造方法中并没有将所有的 Segment 都初始化，而是只初始化了 Segment[0] 的位置
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
// 这个方法就是初始话 Segment 的过程
s = ensureSegment(j);
// 这里才是 将 数据放入 HashEntry 的过程
return s.put(key, hash, value, false);
}
// 先看下是如何初始化 Segment 的吧
private Segment<K,V> ensureSegment(int k) {
final Segment<K,V>[] ss = this.segments;
// 获取偏移量
long u = (k << SSHIFT) + SBASE; // raw offset
// 声明一个 Segment
Segment<K,V> seg;
// 通过偏移量获取 segment 并判断是不是 null
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
// 是null 则最直接获取我们 0 下标的 Segment 上面说过只初始化了 0 下标位置，其余位置都是null
Segment<K,V> proto = ss[0]; // use segment 0 as prototype
// 获取负载因子 长度 阈值 等属性
int cap = proto.table.length;
float lf = proto.loadFactor;
int threshold = (int)(cap * lf);
// 创建 HashEntry
HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
// 再次检查 这个 Segment 是不是 null
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) { // recheck
// 这里只是简单的创建了 Segment 还没有赋值。 因为上面的这些操作都有可能会并发
Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
// 这里就是通过自旋 和 CAS 进行赋值操作。因为提到了 这块有可能还会造成并发
while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) {
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
break;
}
}
}
return seg;
}
如图所示：假设最开始的时候。这个时候我 线程1 和 **线程2 ** 都在执行 put 的操作。我此时插入 key 为 帅 的这个数据，通过计算得出 在 Segment[2] 位置，此时我发现这个位置的 Segment 为 null 便会去初始话这个 Segment 因为 0 下标的位置已经初始化了，所以我这里也不需要直接创建了，直接将 0 位置的数据拿过来即可。也减少了耗时。注意这里我并没有直接赋值哦。 重点来了 这个时候 线程1 停止了，线程2 执行了一系列的并且创建了这个 Segment 也完成了 赋值等等操作。 线程1 又回来了。此时他在做赋值的时候就有问题了。所以就会采用到自旋 + CAS 的操作去执行这些操作。 也就是初始化 Segment 的那段代码中的最后几行。紧着这来看下 HashEntry的 put 操作
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
// 进行获取锁操作 这里会进行 tryLock 不是 Lock 锁哦
// tryLock 是 获取锁定的时候 获取到就返回 true 获取不到 就返回 false。并不会阻塞
// Lock 锁获取不到就会立即阻塞 这里就先大致了解下他们的区别？
// 关于锁后期文章会讲，敬请期待吧。
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
// 插入的方式 就不多解析了 懂了HashMap这里也就懂了。上期也已经讲过HashMap了，不懂的小伙盘可以看上期文章哦
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
if (e != null) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
// 这里会进行这个判断 flase 的时候才插入，true就不插入 ，其实这个东西在调用的时候 就已经传了 flase 没注意看的小伙伴，可以看下 put方法的调用处
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next;
}
else {
if (node != null)
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
// 扩容 后面会讲
rehash(node);
else
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
// 解锁
unlock();
}
return oldValue;
}
获取方法 get
这里就很简单了，先获取是那个 Segment 在从这里 Segment中的 HashEntry 获取值
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;
// 通过偏移量获取 Segment
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
// 遍历HashEntry
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;
// hash相等 && key 相同 返回值
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
扩容
扩容需注意的时候。扩容的时候既不是扩容 Segement 也不是 扩容 所有Segment[] 下面的所有 Entry 而是只扩容 Segment 下的 hashEntry 哦 注意一下。如下图
// 因为 rehash 是在 put 的时候调用的，调用前已经确定了当前这个 HashEntry 在那个 Segment 中了
private void rehash(HashEntry<K,V> node) {
// 获取当前 HashEntry 的长度，
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
// 进行2 倍 扩容
int newCapacity = oldCapacity << 1;
// 计算新的阈值
threshold = (int)(newCapacity * loadFactor);
// 创建 新的HashEntry
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity];
int sizeMask = newCapacity - 1;
// 遍历旧的 HashEntry
for (int i = 0; i < oldCapacity ; i++) {
//获取头节点
HashEntry<K,V> e = oldTable[i];
if (e != null) {
// 获取下一个节点
HashEntry<K,V> next = e.next;
// 扩容后的重新计算 hash
int idx = e.hash & sizeMask;
// 若只有一个数据，直接存放
if (next == null) // Single node on list
newTable[idx] = e;
else { // Reuse consecutive sequence at same slot
// 将头节点赋值 lastRun
HashEntry<K,V> lastRun = e;
int lastIdx = idx;
// 从头节点的 next 开始一直遍历
for (HashEntry<K,V> last = next;
last != null;
last = last.next) {
int k = last.hash & sizeMask;
// 如果 头节点 和 遍历到的节点 计算的hash不一致
if (k != lastIdx) {
lastIdx = k;
// 这个节点便是当前 hash 位置处的 头节点
lastRun = last;
}
}
// 插入数据
newTable[lastIdx] = lastRun;
// 插入剩余节点
for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
V v = p.value;
int h = p.hash;
int k = h & sizeMask;
HashEntry<K,V> n = newTable[k];
newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
}
}
}
}
// 得到这个节点 扩容后的新的位置
int nodeIndex = node.hash & sizeMask; // add the new node
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
// 更新table
table = newTable;
}
删除
public V remove(Object key) {
int hash = hash(key);
// 获取 Segment
Segment<K,V> s = segmentForHash(hash);
return s == null ? null : s.remove(key, hash, null);
}
// 删除操作
final V remove(Object key, int hash, Object value) {
// 尝试去获取锁，获取到了才开始删除，删除操作就不详细说了，和HashMap 都差不多了，不懂小伙伴，看看上期的 HashMap 吧。
if (!tryLock())
scanAndLock(key, hash);
V oldValue = null;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> e = entryAt(tab, index);
HashEntry<K,V> pred = null;
while (e != null) {
K k;
HashEntry<K,V> next = e.next;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
V v = e.value;
if (value == null || value == v || value.equals(v)) {
if (pred == null)
setEntryAt(tab, index, next);
else
pred.setNext(next);
++modCount;
--count;
oldValue = v;
}
break;
}
pred = e;
e = next;
}
} finally {
unlock();
}
return oldValue;
}
好了，本带算在本文中再继续为写 1.8 的实现，但是写太多了。估计大家也没心情看这么多吧。或者也吃不消。劳逸结合嘛，所以 1.8 的 和 Collections.synchronizedMap 我们就留到下期再说吧。其实已经备好了，下期释放。哈哈。
57
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
