ThreadLocal簡析

1. 屬性

ThreadLocal有三個屬性threadLocalHashCode、nextHashCode、HASH_INCREMENT

threadLocalHashCode屬於對象的，每個ThreadLocal對象hashcode在初始化時確定且不可變
nextHashCode屬性是靜態的隨着ThreadLocal類的加載而加載，分配一個AtomicInteger對象，用來以原子的方式獲取最新的hashcode
HASH_INCREMENT是下一個hashcode增長數，是一個靜態常量

public class ThreadLocal<T> {
    // 每個ThreadLocal實例的hashcode(在對象被創建時賦值)
    private final int threadLocalHashCode = nextHashCode();
	// 下一個要給出的hashcode
    private static AtomicInteger nextHashCode = new AtomicInteger();
    // hash增長數
    private static final int HASH_INCREMENT = 0x61c88647;
    
    // 返回下一個hash碼
    private static int nextHashCode() {
        // 原子的方法更新值(調用unsafe操作)
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
}

2. 常用方法

2.1 get()

用來獲取線程的私有變量，操作步驟如下：

獲取當前線程的threadLocalMap屬性，若初始化完成則進入步驟2，否則進行初始化
通過threadLocal去threadLocalMap獲取對應entry，若無entiry則進行初始化

public T get() {
    // 獲取當前線程
    Thread t = Thread.currentThread();
    // 獲取當前線程中threadLocalMap
    ThreadLocalMap map = getMap(t);
    // 判斷threadLocalMap有沒有被初始化
    if (map != null) {
        // 獲取entity
        ThreadLocalMap.Entry e = map.getEntry(this);
        // entity爲null(可能發生內存泄漏，所以設置初始值)
        // 此時的引用鏈爲Thread->ThreadLocalMap->Entry(null)->value
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 初始化
    return setInitialValue();
}

// 獲取線程t的threadLocalMap
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

// 設置初始值
private T setInitialValue() {
    // 初始值(null)
    T value = initialValue();
    // 獲取當前線程
    Thread t = Thread.currentThread();
    // 獲取ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null)
        // 放入map
        map.set(this, value);
    else
		// 創建map
        createMap(t, value);
    return value;
}
// 初始化value
protected T initialValue() {
    return null;
}

2.2 set()

set方法用來設置value到線程的threadLocalMap中

public void set(T value) {
    // 獲取當前線程
    Thread t = Thread.currentThread();
    // 獲取ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

2.3 remove()

移除ThreadLocalmap中的value

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

3. 內部類ThreadLocalMap

ThreadLocalMap的結構如下圖

3.1 爲什麼Entry要繼承弱引用？

Entry實現了對Key(也就是ThreadLocal)的弱引用。如果使用強引用，只要線程沒有被銷燬，ThreadLocal就一直是引用可達狀態，永遠無法被回收，程序不可知ThreadLocal是否可被清理。如果使用弱引用，當沒有強引用鏈可達時，則活不過下一個GC，ThreadLocal會被回收

static class ThreadLocalMap {
    // 內部類Entry，實現了弱引用Key
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    
    // 靜態常量：Table默認初始值
    private static final int INITIAL_CAPACITY = 16;
	// Entry數組
    private Entry[] table;
	// 初始大小
    private int size = 0;
	// 閾值
    private int threshold; // Default to 0
    
    // 實際上Entry[]數組以一個環的形式存在
    // 獲取下一個下標
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }
	// 獲取上一個下標
    private static int prevIndex(int i, int len) {
        return ((i - 1 >= 0) ? i - 1 : len - 1);
    }
    // 構造方法(懶加載，至少放入一個KV)
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        table = new Entry[INITIAL_CAPACITY];	// 16
        // 做與運算確定下標，和HashMap確定下標方式一樣
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        // 構建entry放入table[i]
        table[i] = new Entry(firstKey, firstValue);
        // 設置ThreadLocalMap大小
        size = 1;
        // 設置閾值
        setThreshold(INITIAL_CAPACITY);
    }
}

3.2 getEntity()方法

獲取ThreadLocalMap中的value，步驟如下：

若ThreadLocalMap對應下標處的entry存在且entry的key就是傳入key，返回value，否則進入2
至此說明hash衝突或entry不存在，如果entry不存在，則返回null，否則進入3
從e開始線性探測向後查找不爲null的entry，若命中則返回value，若發現失效entry則進行連續段清理

// 獲取entry，被ThreadLocal的get方法調用
private Entry getEntry(ThreadLocal<?> key) {
    // 與運算獲取到key對應下標
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // 下標處entry存在 且 Entry的弱引用key沒有失效
    if (e != null && e.get() == key)
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}
    
// 在getEntry()中未命中，使用本方法
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    // 基於線性探測法不斷向後探測直至遇到空的Entry
    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 命中
        if (k == key)
            return e;
        if (k == null)
            // 弱引用key失效被回收，清理下標i無效的Entry
            expungeStaleEntry(i); 
        else
            // 線性探測下一個位置
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}
    
// 清除staleSlot開始的陳舊條目(連續段的清理)
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // 下標staleSlot的value引用斷開，原entry的ThreadLocal已被回收，此時原value對象可被回收
    tab[staleSlot].value = null;
    // 下標staleSlot出entry引用斷開
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {
            // 對已回收的Entry進行清理操作
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            // rehash重新確定位置
            int h = k.threadLocalHashCode & (len - 1);
            /**
             * 重新取模後的h位置與原位置i不相等，
             * 則從h向後線性探測找到第一個空的位置，將tab[i]放入
             */
            if (h != i) {
                tab[i] = null;
                
                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    // 返回staleSlot之後第一個空索引
    return i;
}

3.3 set()方法

設置ThreadLocalMap中的kv，步驟如下：

通過hash拿到下標，下標處爲null，直接插入，否則進入2
下標處開始向後遍歷，此時可能遇到三種情況：
- key值相等，直接替換value
- key失效，插入到此位置
是否需要rehash

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    // 獲取key的下標
    int i = key.threadLocalHashCode & (len-1);

    /**
     * hash衝突，下標i位置存在Entry
     * 這時的Entry有兩種狀態：
     * Entry的ThreadLocal未被回收，若ThreadLocal爲k直接放入value
     * Entry的ThreadLocal被回收，替換無效slot
     */
    for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();

        // 找到對應的Entry
        if (k == key) {
            e.value = value;
            return;
        }

        // Entry的ThreadLocal被回收，直接替換
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    // i下標處放入Entry
    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}
    
// 替換陳舊條目
private void replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // 向前遍歷，找到第一個entry存在但key無效的slot
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

	// 向後遍歷tab
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
		
        // 找到對應key，與無效slot交換
        if (k == key) {
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

			// 確定清理點
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            // 做一次連續段清理，再做一次啓發式清理
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // 當前slot無效且向前掃描沒有無效條目，更新slotToExpunge爲當前位置
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // 若key在tab中不存在，直接插入
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // 通過slotToExpunge判斷是否存在無效條目，若存在，清除
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

/**
 * 啓發式清理
 *
 * @param i 永遠爲一個有效條目，從下一個索引開始判斷
 * @param n 掃描log2(n)個單元，除非找到無效slot
 *			插入方法調用時，此參數是元素數量
 * 			replaceStaleEntry方法調用時，此參數是table長度
 * @return 清理過任何無效slot，則返回true
 */
private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        // e爲無效slot
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            // 清理連續段
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    // 刪除過任何無效slot，返回true
    return removed;
}

private void rehash() {
    // 做全量清理
    expungeStaleEntries();
    /**
     * 使用較低閾值判斷是否需要擴容，上面做了清理，size可能會減小
     * 這裏用threshold的3/4來判斷
     */
    if (size >= threshold - threshold / 4)
        resize();
}

// 清除表中所有過時條目
private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        if (e != null && e.get() == null)
            // entry爲無效slot
            expungeStaleEntry(j);
    }
}

// 將table的容量加倍,對遍歷過程中的無效entry直接斷開value
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    // 遍歷確定位置
    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        // 判斷entry存在
        if (e != null) {
            ThreadLocal<?> k = e.get();
            // 判斷key是否有效
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                // 衝突處理
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }

    setThreshold(newLen);
    size = count;
    table = newTab;
}

3.4 remove()方法

通過key移除entry

通過hash找到下標開始位置
向後遍歷直至遇到null爲止，判斷key是否爲傳入的key，若是清理entry並調用連續段清理

private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    // 找到i開始向後查找，找到對應的entry，清理
    for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {
            e.clear();
            // 清理
            expungeStaleEntry(i);
            return;
        }
    }
}

4. ThreadLocal的常見問題？

4.1 ThreadLocal爲什麼發生內存泄露？

因爲ThreadLocal被ThreadLocalMap的Entry以弱引用的方式做key，當發生GC時，ThreadLocal就會被回收，此時引用鏈爲Thread->ThreadLocalMap->Entry(null)->Value，當線程無法結束(線程池場景，使用完後歸還線程池)時，Value將不會被清理，發生內存泄露

解決：使用static修飾ThreadLocal變量，set()，get()使用完成之後手動調用remove()方法清除ThreadLocal

參考：ThreadLocal源碼解讀，散列表–線性探測法，ThreadLocal問題

1. 屬性

2. 常用方法

2.1 get()

2.2 set()

2.3 remove()

3. 內部類ThreadLocalMap

3.1 爲什麼Entry要繼承弱引用？

3.2 getEntity()方法

3.3 set()方法

3.4 remove()方法

4. ThreadLocal的常見問題？

4.1 ThreadLocal爲什麼發生內存泄露？

Rabbitmq個人筆記

idea在debug模式下的類自動加載

算法圖解筆記（附PDF下載地址）

記一次Spring循環依賴問題

JVM的一些相關問題

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結