java基礎解析系列(五)---HashMap並發下的問題以及HashTable和CurrentHashMap的區別
目錄
- java基礎解析系列(一)---String、StringBuffer、StringBuilder
- java基礎解析系列(二)---Integer
- java基礎解析系列(三)---HashMap
- java基礎解析系列(四)---LinkedHashMap的原理及LRU算法的實現
- 這是我的博客目錄，歡迎閱讀
HashMap造成的死循環
resize分析
void resize(int newCapacity) {
472 Entry[] oldTable = table;
473 int oldCapacity = oldTable.length;
474 if (oldCapacity == MAXIMUM_CAPACITY) {
475 threshold = Integer.MAX_VALUE;
476 return;
477 }
478
479 Entry[] newTable = new Entry[newCapacity];
480 transfer(newTable);
481 table = newTable;
482 threshold = (int)(newCapacity * loadFactor);
483 }
void transfer(Entry[] newTable) {
489 Entry[] src = table;
490 int newCapacity = newTable.length;
491 for (int j = 0; j < src.length; j++) {
492 Entry<K,V> e = src[j];
493 if (e != null) {
494 src[j] = null;
495 do {
496 Entry<K,V> next = e.next;//用於判斷后面循環是否繼續
497 int i = indexFor(e.hash, newCapacity);
498 e.next = newTable[i];
499 newTable[i] = e;
500 e = next;
501 } while (e != null);
502 }
503 }
504 }
- 當hashmap大小超過閾值的時候，會進行擴容
- 看看第497到500行代碼做了什么
- 取出原table中的一個Entry e
- 計算該Entry e的在新表的新下標，然后將新table該下標的Entry從新table拿出來，作為Entry e的next，再把將e放到newTable，newTable[i]=e
- 那么其實他做的就是在原table的Entry取出來，計算他的新下標，然后將這個Entry放入新的table，放入新table的時候，是做為鏈頭，原來的Entry接在后面，實際上就相當於鏈表的頭插法
並發情況下的resize
- put完成之后的結果
- 如果此時有兩個線程，線程一完成resize，結果如下
-
此前線程二之前只執行了第一層Entry<K,V> next = e.next，所以對於線程二來說，此時e為3，next是7(這個是判斷后面循環是否終止),然后繼續resize
-
執行497到501的代碼
- while(e!=null),此時e為7，e不為空，進入第二次循環
- next=e.next，即next為7的next(這個是判斷后面循環是否終止)，也就是3（線程一的結果），把7放到鏈表前頭
-
while(e!=null)，此時e=3，e不等於null，進入第三次循環
-
next=e.next(這個是判斷后面循環是否終止)，即3的next，也就是null（造成后面循環終止）
-
放置3這個Entry，3的next設為7（e.next = newTable[i];），而上一步7的next是3，這樣就造成了一個循環
- while(e!=null),e為null循環終止
- 那么如果此時get一個鍵，如果這個鍵的hash值剛好和3相同，那么這個時候就會遍歷鏈表進行查找，而這個鏈表是個循環鏈表，就會造成死循環
- 因此hashmap並不是線程安全
HashTable
對比
public synchronized V get(Object key){}
public synchronized V put(K key, V value) {}
public synchronized V remove(Object key){}
- 用一個表來描述HashMap和HashTable的主要區別
| 對比 | HashMap | HashTable |
|---|---|---|
| 鍵值 | 鍵和value允許null | 不行 |
| synchronized | 非synchronzied | synchronized |
| 單線程情況下速度 | 快 | 慢 |
| 擴容方式 | 2倍 | 2倍+1 |
| 容量 | 初始為16，必須為2的n次方 | 初始為11 |
缺點
- 單線程情況下，也會加鎖
ConcurrentHashMap
HashEntry類
static final class HashEntry<K,V> {
219 final K key;
220 final int hash;
221 volatile V value;
222 final HashEntry<K,V> next;
223
224 HashEntry(K key, int hash, HashEntry<K,V> next, V value) {
225 this.key = key;
226 this.hash = hash;
227 this.next = next;
228 this.value = value;
229 }
230
231 @SuppressWarnings("unchecked")
232 static final <K,V> HashEntry<K,V>[] More ...newArray(int i) {
233 return new HashEntry[i];
234 }
235 }
Segment類
static final class Segment<K,V> extends ReentrantLock implements Serializable {
transient volatile HashEntry<K,V>[] table
315 final float loadFactor;
316
317 Segment(int initialCapacity, float lf) {
318 loadFactor = lf;
319 setTable(HashEntry.<K,V>newArray(initialCapacity));
320 }
321
231 @SuppressWarnings("unchecked")
232 static final <K,V> HashEntry<K,V>[] newArray(int i) {
233 return new HashEntry[i];
234 }
Sets table to new HashEntry array. Call only while holding lock or in constructor.
330
331 void setTable(HashEntry<K,V>[] newTable) {
332 threshold = (int)(newTable.length * loadFactor);
333 table = newTable;
334 }
- Segment繼承了ReentrantLock顯示鎖
- 一個Segement對象維護這一個HashEntry數組
- 構造方法里面調用了newArray方法，這個方法用於創建一個HashEntry數組
CurrentHashMap構造方法
612 public .ConcurrentHashMap(int initialCapacity,
613 float loadFactor, int concurrencyLevel) {
614 if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
615 throw new IllegalArgumentException();
616
617 if (concurrencyLevel > MAX_SEGMENTS)
618 concurrencyLevel = MAX_SEGMENTS;
619
620 // Find power-of-two sizes best matching arguments
621 int sshift = 0;
622 int ssize = 1;
623 while (ssize < concurrencyLevel) {
624 ++sshift;
625 ssize <<= 1;
626 }
627 segmentShift = 32 - sshift;
628 segmentMask = ssize - 1;
629 this.segments = Segment.newArray(ssize);
630
631 if (initialCapacity > MAXIMUM_CAPACITY)
632 initialCapacity = MAXIMUM_CAPACITY;
633 int c = initialCapacity / ssize;
634 if (c * ssize < initialCapacity)
635 ++c;
636 int cap = 1;
637 while (cap < c)
638 cap <<= 1;
639
640 for (int i = 0; i < this.segments.length; ++i)
641 this.segments[i] = new Segment<K,V>(cap, loadFactor);
642 }
- 629行創建了一個Segment數組
- 640-641為Segment數組中的每一個Segment創建一個HashEntry數組
- 那么實際上初始化的時候是先創建一個Segemnt數組，然后每個Segment又創建一個HashEntry數組，可以類比二維數組
CurrentHashMap的put方法
public V put(K key, V value) {
908 if (value == null)
909 throw new NullPointerException();
910 int hash = hash(key.hashCode());
911 return segmentFor(hash).put(key, hash, value, false);
912 }
200 final Segment<K,V> segmentFor(int hash) {
201 return segments[(hash >>> segmentShift) & segmentMask];
202 }
- put的時候通過segmentFor找到segments數組的下標，然后在該segemnt存放鍵值對，實際上就是找到一個HashEntry數組，然后添加到該數組其中一個鏈表中
Segment的put方法
444 V put(K key, int hash, V value, boolean onlyIfAbsent) {
445 lock();
446 try {
447 int c = count;
448 if (c++ > threshold) // ensure capacity
449 rehash();
450 HashEntry<K,V>[] tab = table;
451 int index = hash & (tab.length - 1);
452 HashEntry<K,V> first = tab[index];
453 HashEntry<K,V> e = first;
454 while (e != null && (e.hash != hash || !key.equals(e.key)))
455 e = e.next;
456
457 V oldValue;
458 if (e != null) {
459 oldValue = e.value;
460 if (!onlyIfAbsent)
461 e.value = value;
462 }
463 else {
464 oldValue = null;
465 ++modCount;
466 tab[index] = new HashEntry<K,V>(key, hash, first, value);
467 count = c; // write-volatile
468 }
469 return oldValue;
470 } finally {
471 unlock();
472 }
473 }
- 在前面已經知道Segment繼承了顯式鎖，從445看出，代碼會執行lock方法，也就是加鎖，這是對於一個Segment的，那么也就是如果put的時候找到的Segemnt是不一樣的，那么put的時候不是鎖對象不同就不會產生競爭，這就是相對於HashTable來說的一個優點，不會任何時候都加鎖
CurrentHashMap的get方法
795 public V get(Object key) {
796 int hash = hash(key.hashCode());
797 return segmentFor(hash).get(key, hash);
798 }
- 和put一樣，先在segments數組中找到一個segment，然后執行他的get方法
Segment的get方法
362 V get(Object key, int hash) {
363 if (count != 0) { // read-volatile
364 HashEntry<K,V> e = getFirst(hash);
365 while (e != null) {
366 if (e.hash == hash && key.equals(e.key)) {
367 V v = e.value;
368 if (v != null)
369 return v;
370 return readValueUnderLock(e); // recheck
371 }
372 e = e.next;
373 }
374 }
375 return null;
376 }
377
- getFirst方法找到在Entry數組中對應位置的鏈表的鏈頭，然后對鏈表進行遍歷
- 看下370行的readValueUnderLock方法，源碼也注釋了recheck，作用就是在找當找到對應的鍵后並且value為null的時候，再進行一次查找。
readValueUnderLock
351 V readValueUnderLock(HashEntry<K,V> e) {
352 lock();
353 try {
354 return e.value;
355 } finally {
356 unlock();
357 }
358 }
- 這次查找會進行加鎖，這個過程可能讀到最近覆蓋的一個非空的value，這是對比HashTable的第二個好處，hashtable是對get用synchronized修飾，CurrentHashMap不會在get的時候全程加鎖，減小鎖的粒度，甚至不加鎖
我覺得分享是一種精神，分享是我的樂趣所在，不是說我覺得我講得一定是對的，我講得可能很多是不對的，但是我希望我講的東西是我人生的體驗和思考，是給很多人反思，也許給你一秒鍾、半秒鍾，哪怕說一句話有點道理，引發自己內心的感觸，這就是我最大的價值。（這是我喜歡的一句話，也是我寫博客的初衷）
作者：jiajun 出處： http://www.cnblogs.com/-new/
本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利。如果覺得還有幫助的話，可以點一下右下角的【推薦】，希望能夠持續的為大家帶來好的技術文章！想跟我一起進步么？那就【關注】我吧。