ThreadLocal中黃金分割數(shù)怎么用

這篇文章主要介紹了ThreadLocal中黃金分割數(shù)怎么用，具有一定借鑒價(jià)值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。

一. 前提

最近接觸到的一個(gè)項(xiàng)目要兼容新老系統(tǒng)，最終采用了ThreadLocal(實(shí)際上用的是InheritableThreadLocal)用于在子線程獲取父線程中共享的變量。問題是解決了，但是后來發(fā)現(xiàn)對(duì)ThreadLocal的理解不夠深入，于是順便把它的源碼閱讀理解了一遍。在談到ThreadLocal之前先買個(gè)關(guān)子，先談?wù)匋S金分割數(shù)。本文在閱讀ThreadLocal源碼的時(shí)候是使用JDK8(1.8.0_181)。

二. 黃金分割數(shù)與斐波那契數(shù)列

首先復(fù)習(xí)一下斐波那契數(shù)列，下面的推導(dǎo)過程來自某搜索引擎的wiki：

• 斐波那契數(shù)列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …

• 通項(xiàng)公式：假設(shè)F(n)為該數(shù)列的第n項(xiàng)（n ∈ N*），那么這句話可以寫成如下形式：F(n) = F(n-1) + F(n-2)。

有趣的是，這樣一個(gè)完全是自然數(shù)的數(shù)列，通項(xiàng)公式卻是用無理數(shù)來表達(dá)的。而且當(dāng)n趨向于無窮大時(shí)，前一項(xiàng)與后一項(xiàng)的比值越來越逼近0.618（或者說后一項(xiàng)與前一項(xiàng)的比值小數(shù)部分越來越逼近0.618），而這個(gè)值0.618就被稱為黃金分割數(shù)。證明過程如下：

黃金分割數(shù)的準(zhǔn)確值為(根號(hào)5 - 1)/2，約等于0.618。

三. 黃金分割數(shù)的應(yīng)用

黃金分割數(shù)被廣泛使用在美術(shù)、攝影等藝術(shù)領(lǐng)域，因?yàn)樗哂袊?yán)格的比例性、藝術(shù)性、和諧性，蘊(yùn)藏著豐富的美學(xué)價(jià)值，能夠激發(fā)人的美感。當(dāng)然，這些不是本文研究的方向，我們先嘗試求出無符號(hào)整型和帶符號(hào)整型的黃金分割數(shù)的具體值：

public static void main(String[] args) throws Exception {
    //黃金分割數(shù) * 2的32次方 = 2654435769 - 這個(gè)是無符號(hào)32位整數(shù)的黃金分割數(shù)對(duì)應(yīng)的那個(gè)值
    long c = (long) ((1L << 32) * (Math.sqrt(5) - 1) / 2);
    System.out.println(c);
    //強(qiáng)制轉(zhuǎn)換為帶符號(hào)為的32位整型，值為-1640531527
    int i = (int) c;
    System.out.println(i);
}

通過一個(gè)線段圖理解一下：

也就是2654435769為32位無符號(hào)整數(shù)的黃金分割值，而-1640531527就是32位帶符號(hào)整數(shù)的黃金分割值。而ThreadLocal中的哈希魔數(shù)正是1640531527(十六進(jìn)制為0x61c88647)。為什么要使用0x61c88647作為哈希魔數(shù)？這里提前說一下ThreadLocal在ThreadLocalMap(ThreadLocal在ThreadLocalMap以Key的形式存在)中的哈希求Key下標(biāo)的規(guī)則：

哈希算法：keyIndex = ((i + 1) * HASH_INCREMENT) & (length - 1)

其中，i為ThreadLocal實(shí)例的個(gè)數(shù)，這里的HASH_INCREMENT就是哈希魔數(shù)0x61c88647，length為ThreadLocalMap中可容納的Entry(K-V結(jié)構(gòu))的個(gè)數(shù)(或者稱為容量)。在ThreadLocal中的內(nèi)部類ThreadLocalMap的初始化容量為16，擴(kuò)容后總是2的冪次方，因此我們可以寫個(gè)Demo模擬整個(gè)哈希的過程：

public class Main {

    private static final int HASH_INCREMENT = 0x61c88647;

    public static void main(String[] args) throws Exception {
        hashCode(4);
        hashCode(16);
        hashCode(32);
    }

    private static void hashCode(int capacity) throws Exception {
        int keyIndex;
        for (int i = 0; i < capacity; i++) {
            keyIndex = ((i + 1) * HASH_INCREMENT) & (capacity - 1);
            System.out.print(keyIndex);
            System.out.print(" ");
        }
        System.out.println();
    }
}

上面的例子中，我們分別模擬了ThreadLocalMap容量為4,16,32的情況下，不觸發(fā)擴(kuò)容，并且分別”放入”4,16,32個(gè)元素到容器中，輸出結(jié)果如下：

3 2 1 0 
7 14 5 12 3 10 1 8 15 6 13 4 11 2 9 0 
7 14 21 28 3 10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25 0

每組的元素經(jīng)過散列算法后恰好填充滿了整個(gè)容器，也就是實(shí)現(xiàn)了完美散列。實(shí)際上，這個(gè)并不是偶然，其實(shí)整個(gè)哈希算法可以轉(zhuǎn)換為多項(xiàng)式證明：證明(x - y) HASH_INCREMENT != 2^n (n m)，在x != y，n != m，HASH_INCREMENT為奇數(shù)的情況下恒成立，具體證明可以自行完成。HASH_INCREMENT賦值為0x61c88647的API文檔注釋如下：

連續(xù)生成的哈希碼之間的差異(增量值)，將隱式順序線程本地id轉(zhuǎn)換為幾乎最佳分布的乘法哈希值，這些不同的哈希值最終生成一個(gè)2的冪次方的哈希表。

四. ThreadLocal是什么

下面引用ThreadLocal的API注釋：

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable. ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID)

稍微翻譯一下：ThreadLocal提供線程局部變量。這些變量與正常的變量不同，因?yàn)槊恳粋€(gè)線程在訪問ThreadLocal實(shí)例的時(shí)候（通過其get或set方法）都有自己的、獨(dú)立初始化的變量副本。ThreadLocal實(shí)例通常是類中的私有靜態(tài)字段，使用它的目的是希望將狀態(tài)（例如，用戶ID或事務(wù)ID）與線程關(guān)聯(lián)起來。

ThreadLocal由Java界的兩個(gè)大師級(jí)的作者編寫，Josh Bloch和Doug Lea。Josh Bloch是JDK5語言增強(qiáng)、Java集合(Collection)框架的創(chuàng)辦人以及《Effective Java》系列的作者。Doug Lea是JUC(java.util.concurrent)包的作者，Java并發(fā)編程的泰斗。所以，ThreadLocal的源碼十分值得學(xué)習(xí)。

五. ThreadLocal的原理

ThreadLocal雖然叫線程本地(局部)變量，但是實(shí)際上它并不存放任何的信息，可以這樣理解：它是線程(Thread)操作ThreadLocalMap中存放的變量的橋梁。它主要提供了初始化、set()、get()、remove()幾個(gè)方法。這樣說可能有點(diǎn)抽象，下面畫個(gè)圖說明一下在線程中使用ThreadLocal實(shí)例的set()和get()方法的簡(jiǎn)單流程圖。

假設(shè)我們有如下的代碼，主線程的線程名字是main(也有可能不是main)：

public class Main {

    private static final ThreadLocal<String> LOCAL = new ThreadLocal<>();

    public static void main(String[] args) throws Exception{
        LOCAL.set("doge");
        System.out.println(LOCAL.get());
    }
}

上面只描述了單線程的情況并且因?yàn)槭侵骶€程忽略了Thread t = new Thread()這一步，如果有多個(gè)線程會(huì)稍微復(fù)雜一些，但是原理是不變的，ThreadLocal實(shí)例總是通過Thread.currentThread()獲取到當(dāng)前操作線程實(shí)例，然后去操作線程實(shí)例中的ThreadLocalMap類型的成員變量，因此它是一個(gè)橋梁，本身不具備存儲(chǔ)功能。

六. ThreadLocal源碼分析

對(duì)于ThreadLocal的源碼，我們需要重點(diǎn)關(guān)注set()、get()、remove()幾個(gè)方法。

1. ThreadLocal的內(nèi)部屬性

//獲取下一個(gè)ThreadLocal實(shí)例的哈希魔數(shù)
private final int threadLocalHashCode = nextHashCode();

//原子計(jì)數(shù)器，主要到它被定義為靜態(tài)
private static AtomicInteger nextHashCode = new AtomicInteger();

//哈希魔數(shù)(增長(zhǎng)數(shù))，也是帶符號(hào)的32位整型值黃金分割值的取正
private static final int HASH_INCREMENT = 0x61c88647;

//生成下一個(gè)哈希魔數(shù)
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

這里需要注意一點(diǎn)，threadLocalHashCode是一個(gè)final的屬性，而原子計(jì)數(shù)器變量nextHashCode和生成下一個(gè)哈希魔數(shù)的方法nextHashCode()是靜態(tài)變量和靜態(tài)方法，靜態(tài)變量只會(huì)初始化一次。換而言之，每新建一個(gè)ThreadLocal實(shí)例，它內(nèi)部的threadLocalHashCode就會(huì)增加0x61c88647。舉個(gè)例子：

//t1中的threadLocalHashCode變量為0x61c88647
ThreadLocal t1 = new ThreadLocal();
//t2中的threadLocalHashCode變量為0x61c88647 + 0x61c88647
ThreadLocal t2 = new ThreadLocal();
//t3中的threadLocalHashCode變量為0x61c88647 + 0x61c88647 + 0x61c88647
ThreadLocal t3 = new ThreadLocal();

threadLocalHashCode是下面的ThreadLocalMap結(jié)構(gòu)中使用的哈希算法的核心變量，對(duì)于每個(gè)ThreadLocal實(shí)例，它的threadLocalHashCode是唯一的。

2. 內(nèi)部類ThreadLocalMap的基本結(jié)構(gòu)和源碼分析

ThreadLocal內(nèi)部類ThreadLocalMap使用了默認(rèn)修飾符，也就是包(包私有)可訪問的。ThreadLocalMap內(nèi)部定義了一個(gè)靜態(tài)類Entry。我們重點(diǎn)看下ThreadLocalMap的源碼，先看成員和結(jié)構(gòu)部分：

/**
 * ThreadLocalMap是一個(gè)定制的散列映射，僅適用于維護(hù)線程本地變量。
 * 它的所有方法都是定義在ThreadLocal類之內(nèi)。
 * 它是包私有的，所以在Thread類中可以定義ThreadLocalMap作為變量。
 * 為了處理非常大(指的是值)和長(zhǎng)時(shí)間的用途，哈希表的Key使用了弱引用(WeakReferences)。
 * 引用的隊(duì)列(弱引用)不再被使用的時(shí)候，對(duì)應(yīng)的過期的條目就能通過主動(dòng)刪除移出哈希表。
 */
static class ThreadLocalMap {

        //注意這里的Entry的Key為WeakReference<ThreadLocal<?>>
    static class Entry extends WeakReference<ThreadLocal<?>> {

        //這個(gè)是真正的存放的值
        Object value;
                // Entry的Key就是ThreadLocal實(shí)例本身，Value就是輸入的值
        Entry(ThreadLocal<?> k, Object v) {
                    super(k);
                    value = v;
                }
    }
        //初始化容量，必須是2的冪次方
    private static final int INITIAL_CAPACITY = 16;

        //哈希(Entry)表，必須時(shí)擴(kuò)容，長(zhǎng)度必須為2的冪次方
    private Entry[] table;

        //哈希表中元素(Entry)的個(gè)數(shù)
    private int size = 0;

        //下一次需要擴(kuò)容的閾值，默認(rèn)值為0
    private int threshold;

        //設(shè)置下一次需要擴(kuò)容的閾值，設(shè)置值為輸入值len的三分之二
    private void setThreshold(int len) {
        threshold = len * 2 / 3;
    }

    // 以len為模增加i
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

    // 以len為模減少i
    private static int prevIndex(int i, int len) {
        return ((i - 1 >= 0) ? i - 1 : len - 1);
    }
}

這里注意到十分重要的一點(diǎn)：ThreadLocalMap$Entry是WeakReference(弱引用)，并且鍵值Key為ThreadLocal<?>實(shí)例本身，這里使用了無限定的泛型通配符。

接著看ThreadLocalMap的構(gòu)造函數(shù)：

// 構(gòu)造ThreadLocal時(shí)候使用，對(duì)應(yīng)ThreadLocal的實(shí)例方法void createMap(Thread t, T firstValue)
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    // 哈希表默認(rèn)容量為16
    table = new Entry[INITIAL_CAPACITY];
    // 計(jì)算第一個(gè)元素的哈希碼
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}

// 構(gòu)造InheritableThreadLocal時(shí)候使用，基于父線程的ThreadLocalMap里面的內(nèi)容進(jìn)行提取放入新的ThreadLocalMap的哈希表中
// 對(duì)應(yīng)ThreadLocal的靜態(tài)方法static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap)
private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];
    // 基于父ThreadLocalMap的哈希表進(jìn)行拷貝
    for (Entry e : parentTable) {
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                int h = key.threadLocalHashCode & (len - 1);
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size++;
            }
        }
    }
}

這里注意一下，ThreadLocal的set()方法調(diào)用的時(shí)候會(huì)懶初始化一個(gè)ThreadLocalMap并且放入第一個(gè)元素。而ThreadLocalMap的私有構(gòu)造是提供給靜態(tài)方法ThreadLocal#createInheritedMap()使用的。

接著看ThreadLocalMap提供給ThreadLocal使用的一些實(shí)例方法：

// 如果Key在哈希表中找不到哈希槽的時(shí)候會(huì)調(diào)用此方法
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    // 這里會(huì)通過nextIndex嘗試遍歷整個(gè)哈希表，如果找到匹配的Key則返回Entry
    // 如果哈希表中存在Key == null的情況，調(diào)用expungeStaleEntry進(jìn)行清理
    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

// 1.清空staleSlot對(duì)應(yīng)哈希槽的Key和Value
// 2.對(duì)staleSlot到下一個(gè)空的哈希槽之間的所有可能沖突的哈希表部分槽進(jìn)行重哈希，置空Key為null的槽
// 3.注意返回值是staleSlot之后的下一個(gè)空的哈希槽的哈希碼
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    // 清空staleSlot對(duì)應(yīng)哈希槽的Key和Value
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    // 下面的過程是對(duì)staleSlot到下一個(gè)空的哈希槽之間的所有可能沖突的哈希表部分槽進(jìn)行重哈希，置空Key為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) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            int h = k.threadLocalHashCode & (len - 1);
            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;
            }
        }
    }
    return i;
}

// 這里個(gè)方法比較長(zhǎng)，作用是替換哈希碼為staleSlot的哈希槽中Entry的值
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // Back up to check for prior stale entry in current run.
    // We clean out whole runs at a time to avoid continual
    // incremental rehashing due to garbage collector freeing
    // up refs in bunches (i.e., whenever the collector runs).
    int slotToExpunge = staleSlot;
    // 這個(gè)循環(huán)主要是為了找到staleSlot之前的最前面的一個(gè)Key為null的哈希槽的哈希碼
    for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    // 遍歷staleSlot之后的哈希槽，如果Key匹配則用輸入值替換
    for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        // If we find key, then we need to swap it
        // with the stale entry to maintain hash table order.
        // The newly stale slot, or any other stale slot
        // encountered above it, can then be sent to expungeStaleEntry
        // to remove or rehash all of the other entries in run.
        if (k == key) {
            e.value = value;
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;
            // Start expunge at preceding stale entry if it exists
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // If we didn't find stale entry on backward scan, the
        // first stale entry seen while scanning for key is the
        // first still present in the run.
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }
    // Key匹配不了，則新創(chuàng)建一個(gè)哈希槽
    // If key not found, put new entry in stale slot
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // 這里如果當(dāng)前的staleSlot和找到前置的slotToExpunge不一致會(huì)進(jìn)行一次清理
    // If there are any other stale entries in run, expunge them
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

// 對(duì)當(dāng)前哈希表中所有的Key為null的Entry調(diào)用expungeStaleEntry
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);
    }
}

// 清理第i個(gè)哈希槽之后的n個(gè)哈希槽，如果遍歷的時(shí)候發(fā)現(xiàn)Entry的Key為null，則n會(huì)重置為哈希表的長(zhǎng)度，expungeStaleEntry有可能會(huì)重哈希使得哈希表長(zhǎng)度發(fā)生變化
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;
}

/**
 * 這個(gè)方法主要給`ThreadLocal#get()`調(diào)用，通過當(dāng)前ThreadLocal實(shí)例獲取哈希表中對(duì)應(yīng)的Entry
 *
 */
private Entry getEntry(ThreadLocal<?> key) {
    // 計(jì)算Entry的哈希值
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i]; 
    if (e != null && e.get() == key)
        return e;
    else  // 注意這里，如果e為null或者Key對(duì)不上，會(huì)調(diào)用getEntryAfterMiss
        return getEntryAfterMiss(key, i, e);
}

// 重哈希，必要時(shí)進(jìn)行擴(kuò)容
private void rehash() {
    // 清理所有空的哈希槽，并且進(jìn)行重哈希
    expungeStaleEntries();

    // Use lower threshold for doubling to avoid hysteresis
    // 哈希表的哈希元素個(gè)數(shù)大于3/4閾值時(shí)候觸發(fā)擴(kuò)容
    if (size >= threshold - threshold / 4)
        resize();
}

// 擴(kuò)容，簡(jiǎn)單的擴(kuò)大2倍的容量        
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    for (Entry e : oldTab) {
        if (e != null) {
            ThreadLocal<?> k = e.get();
            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;
}

// 基于ThreadLocal作為key，對(duì)當(dāng)前的哈希表設(shè)置值，此方法由`ThreadLocal#set()`調(diào)用
private void set(ThreadLocal<?> key, Object value) {

    // We don't use a fast path as with get() because it is at
    // least as common to use set() to create new entries as
    // it is to replace existing ones, in which case, a fast
    // path would fail more often than not.

    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匹配，直接設(shè)置值
        if (k == key) {
            e.value = value;
            return;
        }
        // 如果Entry的Key為null，則替換該Key為當(dāng)前的key，并且設(shè)置值
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 清理當(dāng)前新設(shè)置元素的哈希槽下標(biāo)到sz段的哈希槽，如果清理成功并且sz大于閾值則觸發(fā)擴(kuò)容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

簡(jiǎn)單來說，ThreadLocalMap是ThreadLocal真正的數(shù)據(jù)存儲(chǔ)容器，實(shí)際上ThreadLocal數(shù)據(jù)操作的復(fù)雜部分的所有邏輯都在ThreadLocalMap中進(jìn)行，而ThreadLocalMap實(shí)例是Thread的成員變量，在ThreadLocal#set()方法首次調(diào)用的時(shí)候設(shè)置到當(dāng)前執(zhí)行的線程實(shí)例中。如果在同一個(gè)線程中使用多個(gè)ThreadLocal實(shí)例，實(shí)際上，每個(gè)ThreadLocal實(shí)例對(duì)應(yīng)的是ThreadLocalMap的哈希表中的一個(gè)哈希槽。舉個(gè)例子，在主函數(shù)主線程中使用多個(gè)ThreadLocal實(shí)例：

public class ThreadLocalMain {

    private static final ThreadLocal<Integer> TL_1 = new ThreadLocal<>();
    private static final ThreadLocal<String> TL_2 = new ThreadLocal<>();
    private static final ThreadLocal<Long> TL_3 = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        TL_1.set(1);
        TL_2.set("1");
        TL_3.set(1L);
        Field field = Thread.class.getDeclaredField("threadLocals");
        field.setAccessible(true);
        Object o = field.get(Thread.currentThread());
        System.out.println(o);
    }
}

實(shí)際上，主線程的threadLocals屬性中的哈希表中一般不止我們上面定義的三個(gè)ThreadLocal，因?yàn)榧虞d主線程的時(shí)候還有可能在其他地方使用到ThreadLocal，筆者某次Debug的結(jié)果如下：

用PPT畫圖簡(jiǎn)化一下：

上圖threadLocalHashCode屬性一行的表是為了標(biāo)出每個(gè)Entry的哈希槽的哈希值，實(shí)際上，threadLocalHashCode是ThreadLocal@XXXX中的一個(gè)屬性，這是很顯然的，本來threadLocalHashCode就是ThreadLocal的一個(gè)成員變量。

上面只是簡(jiǎn)單粗略對(duì)ThreadLocalMap的源碼進(jìn)行了流水賬的分析，下文會(huì)作一些詳細(xì)的圖，說明一下ThreadLocal和ThreadLocalMap中的一些核心操作的過程。

3. ThreadLocal的創(chuàng)建

從ThreadLocal的構(gòu)造函數(shù)來看，ThreadLocal實(shí)例的構(gòu)造并不會(huì)做任何操作，只是為了得到一個(gè)ThreadLocal的泛型實(shí)例，后續(xù)可以把它作為ThreadLocalMap$Entry的鍵：

// 注意threadLocalHashCode在每個(gè)新`ThreadLocal`實(shí)例的構(gòu)造同時(shí)已經(jīng)確定了
private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

// 通過Supplier去覆蓋initialValue方法
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
    return new SuppliedThreadLocal<>(supplier);
}

// 默認(rèn)公有構(gòu)造函數(shù)
public ThreadLocal() {

}

注意threadLocalHashCode在每個(gè)新ThreadLocal實(shí)例的構(gòu)造同時(shí)已經(jīng)確定了，這個(gè)值也是Entry哈希表的哈希槽綁定的哈希值。

4. TreadLocal的set方法

ThreadLocal中set()方法的源碼如下:

public void set(T value) {
    //設(shè)置值前總是獲取當(dāng)前線程實(shí)例
    Thread t = Thread.currentThread();
    //從當(dāng)前線程實(shí)例中獲取threadLocals屬性
    ThreadLocalMap map = getMap(t);
    if (map != null)
         //threadLocals屬性不為null則覆蓋key為當(dāng)前的ThreadLocal實(shí)例，值為value
         map.set(this, value);
    else
    //threadLocals屬性為null，則創(chuàng)建ThreadLocalMap，第一個(gè)項(xiàng)的Key為當(dāng)前的ThreadLocal實(shí)例，值為value
        createMap(t, value);
}

// 這里看到獲取ThreadLocalMap實(shí)例時(shí)候總是從線程實(shí)例的成員變量獲取
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

// 創(chuàng)建ThreadLocalMap實(shí)例的時(shí)候，會(huì)把新實(shí)例賦值到線程實(shí)例的threadLocals成員
void createMap(Thread t, T firstValue) {
     t.threadLocals = new ThreadLocalMap(this, firstValue);
}

上面的過程源碼很簡(jiǎn)單，設(shè)置值的時(shí)候總是先獲取當(dāng)前線程實(shí)例并且操作它的變量threadLocals。步驟是：

• 獲取當(dāng)前運(yùn)行線程的實(shí)例。

• 通過線程實(shí)例獲取線程實(shí)例成員threadLocals(ThreadLocalMap)，如果為null，則創(chuàng)建一個(gè)新的ThreadLocalMap實(shí)例賦值到threadLocals。

• 通過threadLocals設(shè)置值value，如果原來的哈希槽已經(jīng)存在值，則進(jìn)行覆蓋。

5. TreadLocal的get方法

ThreadLocal中g(shù)et()方法的源碼如下:

 public T get() {
   //獲取當(dāng)前線程的實(shí)例
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
    //根據(jù)當(dāng)前的ThreadLocal實(shí)例獲取ThreadLocalMap中的Entry，使用的是ThreadLocalMap的getEntry方法
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T) e.value;
             return result;
            }
        }
    //線程實(shí)例中的threadLocals為null，則調(diào)用initialValue方法，并且創(chuàng)建ThreadLocalMap賦值到threadLocals
    return setInitialValue();
}

private T setInitialValue() {
    // 調(diào)用initialValue方法獲取值
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    // ThreadLocalMap如果未初始化則進(jìn)行一次創(chuàng)建，已初始化則直接設(shè)置值
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

protected T initialValue() {
     return null;
}

initialValue()方法默認(rèn)返回null，如果ThreadLocal實(shí)例沒有使用過set()方法直接使用get()方法，那么ThreadLocalMap中的此ThreadLocal為Key的項(xiàng)會(huì)把值設(shè)置為initialValue()方法的返回值。如果想改變這個(gè)邏輯可以對(duì)initialValue()方法進(jìn)行覆蓋。

6. TreadLocal的remove方法

ThreadLocal中remove()方法的源碼如下:

public void remove() {
    //獲取Thread實(shí)例中的ThreadLocalMap
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
       //根據(jù)當(dāng)前ThreadLocal作為Key對(duì)ThreadLocalMap的元素進(jìn)行移除
       m.remove(this);
}

七. ThreadLocal.ThreadLocalMap的初始化

我們可以關(guān)注一下java.lang.Thread類里面的變量：

public class Thread implements Runnable {

  //傳遞ThreadLocal中的ThreadLocalMap變量
  ThreadLocal.ThreadLocalMap threadLocals = null;
  //傳遞InheritableThreadLocal中的ThreadLocalMap變量
  ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
}

也就是，ThreadLocal需要存放和獲取的數(shù)據(jù)實(shí)際上綁定在Thread實(shí)例的成員變量threadLocals中，并且是ThreadLocal#set()方法調(diào)用的時(shí)候才進(jìn)行懶加載的，可以結(jié)合上一節(jié)的內(nèi)容理解一下，這里不展開。

八. 什么情況下ThreadLocal的使用會(huì)導(dǎo)致內(nèi)存泄漏

其實(shí)ThreadLocal本身不存放任何的數(shù)據(jù)，而ThreadLocal中的數(shù)據(jù)實(shí)際上是存放在線程實(shí)例中，從實(shí)際來看是線程內(nèi)存泄漏，底層來看是Thread對(duì)象中的成員變量threadLocals持有大量的K-V結(jié)構(gòu)，并且線程一直處于活躍狀態(tài)導(dǎo)致變量threadLocals無法釋放被回收。threadLocals持有大量的K-V結(jié)構(gòu)這一點(diǎn)的前提是要存在大量的ThreadLocal實(shí)例的定義，一般來說，一個(gè)應(yīng)用不可能定義大量的ThreadLocal，所以一般的泄漏源是線程一直處于活躍狀態(tài)導(dǎo)致變量threadLocals無法釋放被回收。但是我們知道，·ThreadLocalMap·中的Entry結(jié)構(gòu)的Key用到了弱引用(·WeakReference<ThreadLocal<?>>·)，當(dāng)沒有強(qiáng)引用來引用ThreadLocal實(shí)例的時(shí)候，JVM的GC會(huì)回收ThreadLocalMap中的這些Key，此時(shí)，ThreadLocalMap中會(huì)出現(xiàn)一些Key為null，但是Value不為null的Entry項(xiàng)，這些Entry項(xiàng)如果不主動(dòng)清理，就會(huì)一直駐留在ThreadLocalMap中。也就是為什么ThreadLocal中g(shù)et()、set()、remove()這些方法中都存在清理ThreadLocalMap實(shí)例key為null的代碼塊。總結(jié)下來，內(nèi)存泄漏可能出現(xiàn)的地方是：

• 大量地(靜態(tài))初始化ThreadLocal實(shí)例，初始化之后不再調(diào)用get()、set()、remove()方法。

• 初始化了大量的ThreadLocal，這些ThreadLocal中存放了容量大的Value，并且使用了這些ThreadLocal實(shí)例的線程一直處于活躍的狀態(tài)。

ThreadLocal中一個(gè)設(shè)計(jì)亮點(diǎn)是ThreadLocalMap中的Entry結(jié)構(gòu)的Key用到了弱引用。試想如果使用強(qiáng)引用，等于ThreadLocalMap中的所有數(shù)據(jù)都是與Thread的生命周期綁定，這樣很容易出現(xiàn)因?yàn)榇罅烤€程持續(xù)活躍導(dǎo)致的內(nèi)存泄漏。使用了弱引用的話，JVM觸發(fā)GC回收弱引用后，ThreadLocal在下一次調(diào)用get()、set()、remove()方法就可以刪除那些ThreadLocalMap中Key為null的值，起到了惰性刪除釋放內(nèi)存的作用。

其實(shí)ThreadLocal在設(shè)置內(nèi)部類ThreadLocal.ThreadLocalMap中構(gòu)建的Entry哈希表已經(jīng)考慮到內(nèi)存泄漏的問題，所以ThreadLocal.ThreadLocalMap$Entry類設(shè)計(jì)為弱引用，類簽名為static class Entry extends WeakReference<ThreadLocal<?>>。之前一篇文章介紹過，如果弱引用關(guān)聯(lián)的對(duì)象如果置為null，那么該弱引用會(huì)在下一次GC時(shí)候回收弱引用關(guān)聯(lián)的對(duì)象。舉個(gè)例子：

public class ThreadLocalMain {

    private static ThreadLocal<Integer> TL_1 = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        TL_1.set(1);
        TL_1 = null;
        System.gc();
        Thread.sleep(300);
    }
}

這種情況下，TL_1這個(gè)ThreadLocal在主動(dòng)GC之后，線程綁定的ThreadLocal.ThreadLocalMap實(shí)例中的Entry哈希表中原來的TL_1所在的哈希槽Entry的引用持有值referent(繼承自WeakReference)會(huì)變成null，但是Entry中的value是強(qiáng)引用，還存放著TL_1這個(gè)ThreadLocal未回收之前的值。這些被”孤立”的哈希槽Entry就是前面說到的要惰性刪除的哈希槽。

感謝你能夠認(rèn)真閱讀完這篇文章，希望小編分享的“ThreadLocal中黃金分割數(shù)怎么用”這篇文章對(duì)大家有幫助，同時(shí)也希望大家多多支持億速云，關(guān)注億速云行業(yè)資訊頻道，更多相關(guān)知識(shí)等著你來學(xué)習(xí)!