硬核剖析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的泛型對象值。

image

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方法具體流程如下：

image

從源碼和流程圖中得知，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方法流程如下：

image

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方法沒有加鎖，也能保證執行緒安全。

image

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();

    }

}

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

image

Tags:

VirMach 便宜 VPS

QNews

QNews