什麼是散列
散列表(hash table)我們平時也叫它哈希表或者Hash表，它用的是數組支持按照下標隨機訪問數據的特性，所以散列表其實就是數組的一種擴展，由數組演化而來。可以說，沒有數組就沒有散列表。
比如我們有100件商品,編號沒有規律的4位數字,現在我們想要通過編號快速獲取商品信息，如何做呢?我們可以將這100件商品信息放到數組裏，通過 商品編號%100這樣的方式得到一個值,值爲1的商品放到數組中下標爲1的位置，值爲2的商品，我們放到數組中下標爲2的位置。以此類推，編號爲K的選手放到數組中下標爲K的位置。因爲商品編號通過散列函數(編號%100)跟數據下標一一對應，所以但我們需要查詢編號爲x的商品信息的時候,我們使用同樣的方式，將編號轉換爲數組下標，就可以從對應的數組下標的位置取出數據。
這就是散列的典型思想。
我們通過上面的例子可以得出這樣規律：散列表用的就是數組支持按照下標隨機訪問的時候，時間複雜度是 O(1) 的特性。通過散列函數(商品編號%100)把元素的鍵值映
射爲下標，然後將數據存儲在數組中對應下標的位置。當我們按照鍵值查詢元素時，我們用同樣的散列函數，將鍵值轉化數組下標，從對應的數組下標的位置取
數據。
開放尋址
一說到散列(或者叫做hash表),大家更熟悉的是HashMap或者LinkedHashMap,而今天的主角是ThreadLocalMap,它是ThreadLocal中的一個內部類。分析ThreadLocal源碼的時候不可能繞過它。
由於哈希表使用了數組,無論hash函數如何設計都無可避免存在hash衝突。上面的例子如果兩件商品的id分別是1001和1101,那麼他們的數據就會就會被放到數組的同一個位置，出現了衝突
鴿巢原理，又名狄利克雷抽屜原理、鴿籠原理。其中一種簡單的表述法爲：若有n個籠子和n+1只鴿子，所有的鴿子都被關在鴿籠裏，那麼至少有一個籠子有至少2只鴿子
ThreadLocalMap作爲hash表的一種實現方式,它是使用什麼方式來解決衝突的呢?它使用了開放尋址法來解決這個問題。
元素插入
開放尋址法的核心是如果出現了散列衝突，就重新探測一個空閒位置，將其插入。當我們往散列表中插入數據時，如果某個數據經過散列函數散列之後，存儲位置已經被佔用了，我們就從當前位置開始，依次往後查找，看是否有空閒位置，直到找到爲止。
image
從圖中可以看出，散列表的大小爲 10 ，在元素 x 插入散列表之前，已經 6 個元素插入到散列表中。 x 經過 Hash 算法之後，被散列到位置下標爲 7 的位置,但是這個位置已經有數據了，所以就產生了衝突。於是我們就順序地往後一個一個找，看有沒有空閒的位置，遍歷到尾部都沒有找到空閒的位置，於是我們再從表頭開始找，直到找到空閒位置 2 ，於是將其插入到這個位置。
元素查找
在散列表中查找元素的過程有點兒類似插入過程。我們通過散列函數求出要查找元素的鍵值對應的散列值，然後比較數組中下標爲散列值的元素和要查找的元素。如果相等，則說明就是我們要找的元素；否則就順序往後依次查找。如果遍歷到數組中的空閒位置，還沒有找到，就說明要查找的元素並沒有在散列表中。
元素刪除
ThreadLocalMap跟數組一樣，不僅支持插入、查找操作，還支持刪除操作。對於使用線性探測法解決衝突的散列表，刪除操作稍微有些特別。我們不能單純地把要刪除的元素設置爲空。
還記得我們剛講的查找操作嗎？在查找的時候，一旦我們通過線性探測方法，找到一個空閒位置，我們就可以認定散列表中不存在這個數據。但是，如果這個空閒位置是我們後來刪除的，就會導致原來的查找算法失效。本來存在的數據，會被認定爲不存在。這個問題如何解決呢？
我們可以在刪除元素之後,將之後不爲null的數據rehash，這樣就不會影響查詢的邏輯
另一種方法是:可以將刪除的元素，特殊標記爲 deleted 。當線性探測查找的時候，遇到標記爲 deleted 的空間，並不是停下來，而是繼續往下探測
rehash
這裏解釋下rehash的過程:當刪除元素8的時候，先把下標爲8的值設置爲null,然後將其後面不爲空的數組元素rehash。比如8後面的元素是9,其原本應該的位置(9%10=9)就在9所以不移動。下一個元素是19,應該在下標爲9的位置,但是已經被佔用了,所以就找下一個空閒的位置，下標爲3的位置是空閒的，放入tab[3]。接着下一個元素1就在tab[1]不移動，
元素7的位置在tab[7]，因爲已經被佔用，放入下一個空閒位置tab[8]。下一個元素仍然是19,這裏由於tab[9]已經被佔用，所以放入下一個空閒位置tab[0]。接着最後一個元素4位置就在tab[4],所以不移動。元素4的下一個位置爲空，整個rehash過程結束。
裝載因子
你可能已經發現了，線性探測法其實存在很大問題。當散列表中插入的數據越來越多時，散列衝突發生的可能性就會越來越大，空閒位置會越來越少，線性探測的時間就會越來越久。極端情況下，我們可能需要探測整個散列表，所以最壞情況下的時間複雜度爲 O(n) 。同理，在刪除和查找時，也有可能會線性探測整張散列表，才能找到要查找或者刪除的數據。
不管採用哪種探測方法，hash函數設計得在合理,當散列表中空閒位置不多的時候，散列衝突的概率就會大大提高。爲了儘可能保證散列表的操作效率，一般情況下，我們會儘可能保證散列表中有一定比例的空閒槽位。我們用裝載因子(load factor)來表示空位的多少。
裝載因子的計算公式是：散列表的裝載因子=填入表中的元素個數/散列表的長度 裝載因子越大，說明空閒位置越少，衝突越多，散列表的性能會下降。
源碼分析
ThreadLocalMap定義
ThreadLocal的核心數據結構是ThreadLocalMap,它的數據結構如下：
static class ThreadLocalMap {
// 這裏的entry繼承WeakReference了
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// 初始化容量,必須是2的n次方
private static final int INITIAL_CAPACITY = 16;
// entry數組,用於存儲數據
private Entry[] table;
// map的容量
private int size = 0;
// 數據量達到多少進行擴容,默認是 table.length * 2 / 3
private int threshold;
從ThreadLocalMap的定義可以看出Entry的key就是ThreadLocal，而value就是值。同時，Entry也繼承WeakReference，所以說Entry所對應key（ThreadLocal實例）的引用爲一個弱引用。而且定義了裝載因子爲數組長度的三分之二。
set()方法
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
// 採用線性探測,尋找合適的插入位置
for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// key存在則直接覆蓋
if (k == key) {
e.value = value;
return;
}
// key不存在,說明之前的ThreadLocal對象被回收了
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 不存在也沒有舊元素,就創建一個
tab[i] = new Entry(key, value);
int sz = ++size;
// 清除舊的槽(entry不爲空，但是ThreadLocal爲空)，並且當數組中元素大於閾值就rehash
if (!cleanSomeSlots(i, sz) && sz >= threshold)
expungeStaleEntries();
// 擴容
if (size >= threshold - threshold / 4)
resize();
}
上面源碼的主要步驟如下:
- 採用線性探測法,尋找合適的插入位置。首先判斷key是否存在,存在則直接覆蓋。如果key不存在證明被垃圾回收了此時需要用新的元素替換舊的元素
- 不存在對應的元素,需要創建一個新的元素
- 清除entry不爲空，但是ThreadLocal(entry的key被回收了)的元素，防止內存泄露
- 如果滿足條件:size >= threshold - threshold / 4就將數組擴大爲之前的兩倍，同時會重新計算數組元素所處的位置並進行移動(rehash)。比如最開始數組初始大小爲16,當size >= (16*2/3=10) - (10/4) = 8的時候就會擴容,將數組大小擴容至32.
無論是replaceStaleEntry()方法還是cleanSomeSlots()方法，最重要的方法調用是expungeStaleEntry(),你可以在ThreadLocalMap中的get,set,remove都能發現調用它的身影。
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 刪除對應位置的entry
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
Entry e;
int i;
// rehash過程,直到entry爲null
for (i = nextIndex(staleSlot, len);(e = tab[i]) != null; i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// k爲空,證明已經被垃圾回收了
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
// 判斷當前元素是否處於"真正"應該待的位置
if (h != i) {
tab[i] = null;
// 線性探測
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
上面rehash的代碼結合文章開頭的說明理解起來更是容易,當從ThreadLocalMap新增,獲取,刪除的時候都會根據條件進行rehash，條件如下
- ThreadLocal對象被回收,此時Entry中key爲null,value不爲null。這時會觸發rehash
- 當閾值達到ThreadLocalMap容量的三分之二的時候
get()方法
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
// 現在數據中進行查找
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
// 採用線性探測找到對應元素
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal<?> k = e.get();
// 找到元素
if (k == key)
return e;
// ThreadLocal爲空,需要刪除過期元素，同時進行rehash
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
線性探測法貫穿了get,set的所有流程，理解了原理在看代碼就很簡單了。
remove()方法
private void remove(ThreadLocal<?> key) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
if (e.get() == key) {
e.clear();
expungeStaleEntry(i);
return;
}
}
}
remove的時候回刪除舊的entry,然後進行rehash.
ThreadLocal的使用
public class Counter {
private static ThreadLocal<Integer> seqCount = new ThreadLocal<Integer>(){
public Integer initialValue() {
return 0;
}
};
public int nextInt(){
seqCount.set(seqCount.get() + 1);
return seqCount.get();
}
public static void main(String[] args){
Counter seqCount = new Counter();
CountThread thread1 = new CountThread(seqCount);
CountThread thread2 = new CountThread(seqCount);
CountThread thread3 = new CountThread(seqCount);
CountThread thread4 = new CountThread(seqCount);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
private static class CountThread extends Thread{
private Counter counter;
CountThread(Counter counter){
this.counter = counter;
}
@Override
public void run() {
for(int i = 0 ; i < 3 ; i++){
System.out.println(Thread.currentThread().getName() + " seqCount :" + counter.nextInt());
}
}
}
}
運行效果如下：
Thread-3 seqCount :1
Thread-0 seqCount :1
Thread-3 seqCount :2
Thread-0 seqCount :2
Thread-0 seqCount :3
Thread-2 seqCount :1
Thread-2 seqCount :2
Thread-1 seqCount :1
Thread-3 seqCount :3
Thread-1 seqCount :2
Thread-1 seqCount :3
Thread-2 seqCount :3
ThreadLocal 其實是爲每個線程都提供一份變量的副本, 從而實現同時訪問而不受影響。從這裏也看出來了它和synchronized之間的應用場景不同, synchronized是爲了讓每個線程對變量的修改都對其他線程可見, 而 ThreadLocal 是爲了線程對象的數據不受其他線程影響, 它最適合的場景應該是在同一線程的不同開發層次中共享數據。