快捷導(dǎo)航

Java中的ThreadLocalMap源碼解讀

更新時(shí)間：2023年09月26日 10:30:00 作者：回家放羊吧

這篇文章主要介紹了Java中的ThreadLocalMap源碼解讀,ThreadLocalMap是ThreadLocal的內(nèi)部類,是一個(gè)key-value數(shù)據(jù)形式結(jié)構(gòu),也是ThreadLocal的核心,需要的朋友可以參考下

概述

ThreadLocalMap是ThreadLocal的內(nèi)部類，是一個(gè)key-value數(shù)據(jù)形式結(jié)構(gòu)，也是ThreadLocal的核心。

ThreadLocalMap中數(shù)據(jù)是存儲(chǔ)在Entry類型數(shù)組的table中的，Entry繼承了WeakReference（弱引用），注意key是弱引用，vlaue不是。

源碼解讀

1.成員變量

/**
	 * 初始容量
	 */
	private static final int INITIAL_CAPACITY = 16;
	/**
	 * ThreadLocalMap數(shù)據(jù)真正存儲(chǔ)在table中
	 */
	private Entry[] table;
	/**
	 * ThreadLocalMap條數(shù)
	 */
	private int size = 0;
	/**
	 * 達(dá)到這個(gè)大小，則擴(kuò)容
	 */
	private int threshold; // 默認(rèn)為0

2.threadLocalHashCode

private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
/**
 * The difference between successively generated hash codes - turns
  * implicit sequential thread-local IDs into near-optimally spread
  * multiplicative hash values for power-of-two-sized tables.
  */
 private static final int HASH_INCREMENT = 0x61c88647;
 /**
  * Returns the next hash code.
  */
 private static int nextHashCode() {
     return nextHashCode.getAndAdd(HASH_INCREMENT);
 }

HASH_INCREMENT = 0x61c88647是一個(gè)魔法數(shù)，可以減少hash沖突，通過nextHashCode.getAndAdd(HASH_INCREMENT)方法會(huì)轉(zhuǎn)化為二進(jìn)制數(shù)據(jù)，主要作用是增加哈希值，減少哈希沖突

3.構(gòu)造函數(shù)

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        //初始化table數(shù)組，INITIAL_CAPACITY默認(rèn)值為16
        table = new Entry[INITIAL_CAPACITY];
        //key和16取得哈希值
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        //創(chuàng)建節(jié)點(diǎn)，設(shè)置key-value
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        //設(shè)置擴(kuò)容閾值
        setThreshold(INITIAL_CAPACITY);
}

4.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();
            if (k == key) {
                //如果key是相同，則替換，并return
                e.value = value;
                return;
            }
            if (k == null) {
                //e！=null，key==null，因?yàn)閗ey是弱引用，所以key已經(jīng)被gc回收了，replaceStaleEntry方法就是用來(lái)解決內(nèi)存泄露問題
                replaceStaleEntry(key, value, i);
                return;
            }
        }
        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;
        int slotToExpunge = staleSlot;
        //prevIndex是指針向前，尋找前面過期數(shù)據(jù)
        for (int i = prevIndex(staleSlot, len);
             (e = tab[i]) != null;
             i = prevIndex(i, len))
            if (e.get() == null)
                slotToExpunge = i;
        //向后尋找key相同的數(shù)據(jù)
        for (int i = nextIndex(staleSlot, len);
             (e = tab[i]) != null;
             i = nextIndex(i, len)) {
            ThreadLocal<?> k = e.get();
            if (k == key) {
                e.value = value;
                //通過和過期的slot進(jìn)行交換，維護(hù)哈希表順序
                tab[i] = tab[staleSlot];
                tab[staleSlot] = e;
                if (slotToExpunge == staleSlot)
                    slotToExpunge = i;
                //清除過期slot
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                return;
            }
             if (k == null && slotToExpunge == staleSlot)
                slotToExpunge = i;
        }
        // 如果key并沒有在map中出現(xiàn)過，則直接創(chuàng)建
        tab[staleSlot].value = null;
        tab[staleSlot] = new Entry(key, value);
        //如果還有其他過期slot，則清除
        if (slotToExpunge != staleSlot)
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
    }
    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];
            if (e != null && e.get() == null) {
                n = len;
                removed = true;
                i = expungeStaleEntry(i);
            }
        } while ( (n >>>= 1) != 0);
        return removed;
    }
    private int expungeStaleEntry(int staleSlot) {
        Entry[] tab = table;
        int len = tab.length;
        // 刪除下標(biāo)為staleSlot的slot
        tab[staleSlot].value = null;
        tab[staleSlot] = null;
        size--;
        // 重新哈希，直到遇到null
        Entry e;
        int i;
        for (i = nextIndex(staleSlot, len);
             (e = tab[i]) != null;
             i = nextIndex(i, len)) {
            ThreadLocal<?> k = e.get();
            //如果key==null，說明已經(jīng)被回收
            if (k == null) {
                //Entry設(shè)置為null，size減一
                e.value = null;
                tab[i] = null;
                size--;
            } else {
                //重新進(jìn)行hash計(jì)算
                int h = k.threadLocalHashCode & (len - 1);
                //如果計(jì)算的位置和從前位置不一致
                if (h != i) {
                    tab[i] = null;
                    //掃描到null，將值放入
                    while (tab[h] != null)
                        h = nextIndex(h, len);
                    tab[h] = e;
                }
            }
        }
        return i;
    }
    private void rehash() {
            expungeStaleEntries();
            //如果當(dāng)前size大于法制的四分之三，則擴(kuò)容
            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)
                expungeStaleEntry(j);
        }
    }

set方法首先根據(jù)key計(jì)算存儲(chǔ)位置如果計(jì)算出來(lái)的下標(biāo)不為空，會(huì)進(jìn)入循環(huán)，循環(huán)內(nèi)如果key相同，則直接替換，如果key被回收，則調(diào)用replaceStaleEntry方法清除，并且在該方法中設(shè)置value。如果計(jì)算出來(lái)的下標(biāo)為空，則直接設(shè)置值，并在最后通過cleanSomeSlots清除過期key和確定是否通過rehash擴(kuò)容。

5.getEntry

 	private Entry getEntry(ThreadLocal<?> key) {
        //計(jì)算下標(biāo)位置
        int i = key.threadLocalHashCode & (table.length - 1);
        Entry e = table[i];
        //沒有hash沖突，entry存在，并且key未被回收
        if (e != null && e.get() == key)
            return e;
        else
            //hash沖突，通過線性探測(cè)查找，可能查詢到
            return getEntryAfterMiss(key, i, e);
    }
    private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
        Entry[] tab = table;
        int len = tab.length;
		//循環(huán)查找，直到為null
        while (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == key)
                return e;
            if (k == null)
                //被回收了，清除
                expungeStaleEntry(i);
            else
                //循環(huán)下一個(gè)
                i = nextIndex(i, len);
            e = tab[i];
        }
        return null;
    }

getEntry是根據(jù)ThreadLocal獲取ThreadLocalMap中某個(gè)值的，如果存在哈希沖突則通過getEntryAfterMiss方法線性探測(cè)查找

6.remove

private void remove(ThreadLocal<?> key) {
        Entry[] tab = table;
        int len = tab.length;
        int i = key.threadLocalHashCode & (len-1);
        //如果threadLocalHashCode計(jì)算出的下標(biāo)找到的key和傳入key不同，則證明出現(xiàn)哈希沖突，則循環(huán)向下查找
        for (Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            //如果key相同
            if (e.get() == key) {
                //刪除當(dāng)前Entry
                e.clear();
                //清理
                expungeStaleEntry(i);
                return;
            }
        }
    }