硬核剖析ThreadLocal原始碼，面試官看了直呼內行

工作面試中經常遇到ThreadLocal，但是很多同學並不瞭解ThreadLocal實現原理，到底為什麼會發生記憶體漏失也是一知半解？今天一燈帶你深入剖析ThreadLocal原始碼，總結ThreadLocal使用規範，解析ThreadLocal高頻面試題。

1. ThreadLocal是什麼

ThreadLocal是執行緒本地變數，就是執行緒的私有變數，不同執行緒之間相互隔離，無法共用，相當於每個執行緒拷貝了一份變數的副本。

目的就是在多執行緒環境中，無需加鎖，也能保證資料的安全性。

2. ThreadLocal的使用

/**
 * @author 一燈架構
 * @apiNote ThreadLocal範例
 **/
public class ThreadLocalDemo {
    // 1. 建立ThreadLocal
    static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        // 2. 給ThreadLocal賦值
        threadLocal.set("關注公眾號:一燈架構");
        // 3. 從ThreadLocal中取值
        String result = threadLocal.get();
        System.out.println(result); // 輸出 關注公眾號:一燈架構
        
        // 4. 刪除ThreadLocal中的資料
        threadLocal.remove();
        System.out.println(threadLocal.get()); // 輸出null
    }

}

ThreadLocal的用法非常簡單，建立ThreadLocal的時候指定泛型型別，然後就是賦值、取值、刪除值的操作。

不同執行緒之間，ThreadLocal資料是隔離的，測試一下：

/**
 * @author 一燈架構
 * @apiNote ThreadLocal範例
 **/
public class ThreadLocalDemo {
    // 1. 建立ThreadLocal
    static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        IntStream.range(0, 5).forEach(i -> {
          	// 建立5個執行緒，分別給threadLocal賦值、取值
            new Thread(() -> {
                // 2. 給ThreadLocal賦值
                threadLocal.set(i);
                // 3. 從ThreadLocal中取值
                System.out.println(Thread.currentThread().getName()
                        + "," + threadLocal.get());
            }).start();
        });
    }

}

輸出結果：

Thread-2,2
Thread-4,4
Thread-1,1
Thread-0,0
Thread-3,3

可以看出不同執行緒之間的ThreadLocal資料相互隔離，互不影響，這樣的實現效果有哪些應用場景呢？

3. ThreadLocal應用場景

ThreadLocal的應用場景主要分為兩類：

1. 避免物件在方法之間層層傳遞，打破層次間約束。

   比如使用者資訊，在很多地方都需要用到，層層往下傳遞，比較麻煩。這時候就可以把使用者資訊放到ThreadLocal中，需要的地方可以直接使用。

2. 拷貝物件副本，減少初始化操作，並保證資料安全。

   比如資料庫連線、Spring事務管理、SimpleDataFormat格式化日期，都是使用的ThreadLocal，即避免每個執行緒都初始化一個物件，又保證了多執行緒下的資料安全。

使用ThreadLocal保證SimpleDataFormat格式化日期的執行緒安全，程式碼類似下面這樣：

/**
 * @author 一燈架構
 * @apiNote ThreadLocal範例
 **/
public class ThreadLocalDemo {
    // 1. 建立ThreadLocal
    static ThreadLocal<SimpleDateFormat> threadLocal =
            ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));


    public static void main(String[] args) {
        IntStream.range(0, 5).forEach(i -> {
            // 建立5個執行緒，分別從threadLocal取出SimpleDateFormat，然後格式化日期
            new Thread(() -> {
                try {
                    System.out.println(threadLocal.get().parse("2022-11-11 00:00:00"));
                } catch (ParseException e) {
                    throw new RuntimeException(e);
                }
            }).start();
        });
    }

}

4. ThreadLocal實現原理

ThreadLocal底層使用ThreadLocalMap儲存資料，而ThreadLocalMap內部是一個陣列，陣列裡面儲存的是Entry物件，Entry物件裡面使用key-value儲存資料，key是ThreadLocal範例物件本身，value是ThreadLocal的泛型物件值。

4.1 ThreadLocalMap原始碼

static class ThreadLocalMap {
    // Entry物件，WeakReference是弱參照，當沒有參照指向時，會被GC回收
    static class Entry extends WeakReference<ThreadLocal<?>> {
        // ThreadLocal泛型物件值
        Object value;
        // 構造方法，傳參是key-value
        // key是ThreadLocal物件範例，value是ThreadLocal泛型物件值
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
  
    // Entry陣列，用來儲存ThreadLocal資料
    private Entry[] table;
    // 陣列的預設容量大小
    private static final int INITIAL_CAPACITY = 16;
    // 擴容的閾值，預設是陣列大小的三分之二
    private int threshold;

    private void setThreshold(int len) {
        threshold = len * 2 / 3;
    }
}

4.2 set方法原始碼

// 給ThreadLocal設值
public void set(T value) {
    // 獲取當前執行緒物件
    Thread t = Thread.currentThread();
    // 獲取此執行緒物件中的ThreadLocalMap物件
    ThreadLocalMap map = getMap(t);
    // 如果ThreadLocal已經設過值，直接設值，否則初始化
    if (map != null)
        // 設值的key就是當前ThreadLocal物件範例，value是ThreadLocal泛型物件值
        map.set(this, value);
    else
        // 初始化ThreadLocalMap
        createMap(t, value);
}

再看一下實際的set方法原始碼：

// key就是當前ThreadLocal物件範例，value是ThreadLocal泛型物件值
private void set(ThreadLocal<?> key, Object value) {
    // 獲取ThreadLocalMap中的Entry陣列
    Entry[] tab = table;
    int len = tab.length;
    // 計算key在陣列中的下標，也就是ThreadLocal的hashCode和陣列大小-1取餘
    int i = key.threadLocalHashCode & (len - 1);

    // 查詢流程：從下標i開始，判斷下標位置是否有值，
    // 如果有值判斷是否等於當前ThreadLocal物件範例，等於就覆蓋，否則繼續向後遍歷陣列，直到找到空位置
    for (Entry e = tab[i];
         e != null;
        // nextIndex 就是讓在不超過陣列長度的基礎上，把陣列的索引位置 + 1
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        // 如果等於當前ThreadLocal物件範例，直接覆蓋
        if (k == key) {
            e.value = value;
            return;
        }
        // 當前key是null，說明ThreadLocal物件範例已經被GC回收了，直接覆蓋
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // 找到空位置，建立Entry物件
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 當陣列大小大於等於擴容閾值(陣列大小的三分之二)時，進行擴容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

set方法具體流程如下：

從原始碼和流程圖中得知，ThreadLocal是通過線性探測法解決雜湊衝突的，線性探測法具體賦值流程如下：

1. 通過key的hashcode找到陣列下標
2. 如果陣列下標位置是空或者等於當前ThreadLocal物件，直接覆蓋值結束
3. 如果不是空，就繼續向下遍歷，遍歷到陣列結尾後，再從頭開始遍歷，直到找到陣列為空的位置，在此位置賦值結束

線性探測法這種特殊的賦值流程，導致取值的時候，也要走一遍類似的流程。

4.3 get方法原始碼

// 從ThreadLocal從取值
public T get() {
    // 獲取當前執行緒物件
    Thread t = Thread.currentThread();
    // 獲取此執行緒物件中的ThreadLocalMap物件
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 通過ThreadLocal範例物件作為key，在Entry陣列中查詢資料
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 如果不為空，表示找到了，直接返回
        if (e != null) {
            T result = (T)e.value;
            return result;
        }
    }
    // 如果ThreadLocalMap是null，就執行初始化ThreadLocalMap操作
    return setInitialValue();
}

再看一下具體的遍歷Entry陣列的邏輯：

// 具體的遍歷Entry陣列的方法
private Entry getEntry(ThreadLocal<?> key) {
    // 通過hashcode計算陣列下標位置
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // 如果下標位置物件不為空，並且等於當前ThreadLocal範例物件，直接返回
    if (e != null && e.get() == key)
        return e;
    else
        // 如果不是，需要繼續向下遍歷Entry陣列
        return getEntryAfterMiss(key, i, e);
}

再看一下線性探測法特殊的取值方法：

// 如果不是，需要繼續向下遍歷Entry陣列
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    // 迴圈遍歷陣列，直到找到ThreadLocal物件，或者遍歷到陣列為空的位置
    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 如果等於當前ThreadLocal範例物件，表示找到了，直接返回
        if (k == key)
            return e;
        // key是null，表示ThreadLocal範例物件已經被GC回收，就幫忙清除value
        if (k == null)
            expungeStaleEntry(i);
        else
          	// 索引位置+1，表示繼續向下遍歷
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

// 索引位置+1，表示繼續向下遍歷，遍歷到陣列結尾，再從頭開始遍歷
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

ThreadLocal的get方法流程如下：

4.4 remove方法原始碼

remove方法流程跟set、get方法類似，都是遍歷陣列，找到ThreadLocal範例物件後，刪除key、value，再刪除Entry物件結束。

public void remove() {
    // 獲取當前執行緒的ThreadLocalMap物件
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

// 具體的刪除方法
private void remove(ThreadLocal<?> key) {
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;
    // 計算陣列下標
    int i = key.threadLocalHashCode & (len - 1);
    // 遍歷陣列，直到找到空位置，
    // 或者值等於當前ThreadLocal物件，才結束
    for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        // 找到後，刪除key、value，再刪除Entry物件
        if (e.get() == key) {
            e.clear();
            expungeStaleEntry(i);
            return;
        }
    }
}

5. ThreadLocal使用注意事項

使用ThreadLocal結束，一定要呼叫remove方法，清理掉threadLocal資料。具體流程類似下面這樣：

/**
 * @author 一燈架構
 * @apiNote ThreadLocal範例
 **/
public class ThreadLocalDemo {
    // 1. 建立ThreadLocal
    static ThreadLocal<User> threadLocal = new ThreadLocal<>();

    public void method() {
        try {
            User user = getUser();
            // 2. 給threadLocal賦值
            threadLocal.set(user);
            // 3. 執行其他業務邏輯
            doSomething();
        } finally {
            // 4. 清理threadLocal資料
            threadLocal.remove();
        }
    }
}

如果忘了呼叫remove方法，可能會導致兩個嚴重的問題：

1. 導致記憶體溢位

   如果執行緒的生命週期很長，一直往ThreadLocal中放資料，卻沒有刪除，最終產生OOM

2. 導致資料錯亂

   如果使用了執行緒池，一個執行緒執行完任務後並不會被銷燬，會繼續執行下一個任務，導致下個任務存取到了上個任務的資料。

6. 常見面試題剖析

看完了ThreadLocal原始碼，再回答幾道面試題，檢驗一下學習成果怎麼樣。

6.1 ThreadLocal是怎麼保證資料安全性的？

ThreadLocal底層使用的ThreadLocalMap儲存資料，而ThreadLocalMap是執行緒Thread的私有變數，不同執行緒之間資料隔離，所以即使ThreadLocal的set、get、remove方法沒有加鎖，也能保證執行緒安全。

6.2 ThreadLocal底層為什麼使用陣列？而不是一個物件？

因為在一個執行緒中可以建立多個ThreadLocal範例物件，所以要用陣列儲存，而不是用一個物件。

6.3 ThreadLocal是怎麼解決雜湊衝突的？

ThreadLocal使用的線性探測法法解決雜湊衝突，線性探測法法具體賦值流程如下：

1. 通過key的hashcode找到陣列下標
2. 如果陣列下標位置是空或者等於當前ThreadLocal物件，直接覆蓋值結束
3. 如果不是空，就繼續向下遍歷，遍歷到陣列結尾後，再從頭開始遍歷，直到找到陣列為空的位置，在此位置賦值結束

6.4 ThreadLocal為什麼要用線性探測法解決雜湊衝突？

我們都知道HashMap採用的是鏈地址法（也叫拉鍊法）解決雜湊衝突，為什麼ThreadLocal要用線性探測法解決雜湊衝突？而不用鏈地址法呢？

我的猜想是可能是創作者偷懶、嫌麻煩，或者是ThreadLocal使用量較少，出現雜湊衝突概率較低，不想那麼麻煩。

使用鏈地址法需要引入連結串列和紅黑樹兩種資料結構，實現更復雜。而線性探測法沒有引入任何額外的資料結構，直接不斷遍歷陣列。

結果就是，如果一個執行緒中使用很多個ThreadLocal，發生雜湊衝突後，ThreadLocal的get、set效能急劇下降。

線性探測法相比鏈地址法優缺點都很明顯：

優點： 實現簡單，無需引入額外的資料結構。

缺點： 發生雜湊衝突後，ThreadLocal的get、set效能急劇下降。

6.5 ThreadLocalMap的key為什麼要設計成弱參照？

先說一下弱參照的特點：

弱參照的物件擁有更短暫的生命週期，在垃圾回收器執行緒掃描它所管轄的記憶體區域的過程中，一旦發現了只具有弱參照的物件，不管當前記憶體空間足夠與否，都會回收它的記憶體。 不過，由於垃圾回收器是一個優先順序很低的執行緒，因此不一定會很快發現那些只具有弱參照的物件。

ThreadLocalMap的key設計成弱參照後，會不會我們正在使用，就被GC回收了？

這個是不會的，因為我們一直在強參照著ThreadLocal範例物件。

/**
 * @author 一燈架構
 * @apiNote ThreadLocal範例
 **/
public class ThreadLocalDemo {
    // 1. 建立ThreadLocal
    static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        // 2. 給ThreadLocal賦值
        threadLocal.set("關注公眾號:一燈架構");
        // 3. 從ThreadLocal中取值
        String result = threadLocal.get();
        // 手動觸發GC
        System.gc();
        System.out.println(result); // 輸出 關注公眾號:一燈架構

    }

}

由上面程式碼中得知，如果我們一直在使用threadLocal，觸發GC後，並不會threadLocal範例物件。

ThreadLocalMap的key設計成弱參照的目的就是：

防止我們在使用完ThreadLocal後，忘了呼叫remove方法刪除資料，導致陣列中ThreadLocal資料一直不被回收。

/**
 * @author 一燈架構
 * @apiNote ThreadLocal範例
 **/
public class ThreadLocalDemo {
    // 1. 建立ThreadLocal
    static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        // 2. 給ThreadLocal賦值
        threadLocal.set("關注公眾號:一燈架構");
        // 3. 使用完threadLocal，設定成null，模仿生命週期結束
        threadLocal = null;
        // 觸發GC，這時候ThreadLocalMap的key就會被回收，但是value還沒有被回收。
        // 只有等到下次執行get、set方法遍歷陣列，遍歷到這個位置，才會刪除這個無效的value
        System.gc();
    }

}

6.6 ThreadLocal為什麼會出現記憶體漏失？

ThreadLocal出現記憶體漏失的原因，就是我們使用完ThreadLocal沒有執行remove方法刪除資料。

具體是哪些資料過多導致的記憶體漏失呢？

一個是陣列的Entry物件，Entry物件中key、value分別是ThreadLocal範例物件和泛型物件值。

因為我們在使用ThreadLocal的時候，總愛把ThreadLocal設定成類的靜態變數，直到執行緒生命週期結束，ThreadLocal物件資料才會被回收。

另一個是陣列中Entry物件的value值，也就是泛型物件值。雖然ThreadLocalMap的key被設定成弱參照，會被GC回收，但是value並沒有被回收。需要等到下次執行get、set方法遍歷陣列，遍歷到這個位置，才會刪除這個無效的value。這也是造成記憶體漏失的原因之一。

6.7 怎麼實現父子執行緒共用ThreadLocal資料？

只需要InheritableThreadLocal即可，當初始化子執行緒的時候，會從父執行緒拷貝ThreadLocal資料。

/**
 * @author 一燈架構
 * @apiNote ThreadLocal範例
 **/
public class ThreadLocalDemo {
    // 1. 建立可被子執行緒繼承資料的ThreadLocal
    static ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) {
        // 2. 給ThreadLocal賦值
        threadLocal.set("關注公眾號:一燈架構");

        // 3. 啟動一個子執行緒，看是否能獲取到主執行緒資料
        new Thread(() -> {
            System.out.println(threadLocal.get()); // 輸出 關注公眾號:一燈架構
        }).start();

    }

}

我是「一燈架構」，如果本文對你有幫助，歡迎各位小夥伴點贊、評論和關注，感謝各位老鐵，我們下期見