Java 線程深度解析：ThreadLocal 核心原理與手寫實現

ThreadLocal 不是「副本」，是「線程隔離的變量容器」

Java API 描述：ThreadLocal 提供線程局部變量，多線程使用時每個線程只能拿到該變量的一個「副本」。但細讀源碼發現，並非副本（克隆品），概念太模糊。

準確說法：ThreadLocal 類型變量本身只有一個，但其內部註冊表（Map<Thread, T>）發生了變化——這才是本質！

標準示例：四個線程各自獨立計數

MyThreadLocal 封裝 ThreadLocal<Integer>，提供 getNextNum() 遞增獲取：

public class MyThreadLocal {
    private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {
        @Override protected Integer initialValue() { return 0; }
    };
    public Integer getNextNum() {
        tl.set(tl.get() + 1);
        return tl.get();
    }
}

TestThread 共享同一 MyThreadLocal 實例：

public class TestThread extends Thread {
    private MyThreadLocal tlt;
    public TestThread(MyThreadLocal tlt) { this.tlt = tlt; }
    @Override public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "\t" + tlt.getNextNum());
        }
    }
}

測試主程序 創建四線程：

public class Test {
    public static void main(String[] args) {
        MyThreadLocal tlt = new MyThreadLocal();
        new TestThread(tlt).start();
        new TestThread(tlt).start();
        new TestThread(tlt).start();
        new TestThread(tlt).start();
    }
}

輸出：四線程各自獨立從 1 遞增到 3，互不影響：

Thread-0 1
Thread-1 1
Thread-0 2
Thread-1 2
Thread-0 3
Thread-1 3
Thread-2 1
Thread-3 1
Thread-2 2
Thread-3 2
Thread-2 3
Thread-3 3

tlt 對象是一個，tl 也只有一個（組合關係一對一）。但 tl 內部 Map 隨線程增多創建多個 Integer 對象。因 Integer/int 通用，感覺不到對象屬性。

對比：不使用 ThreadLocal 的共享變量混亂

將 MyThreadLocal 改為普通 Integer t1 = 0：

Thread-2 1
Thread-2 2
Thread-1 4
Thread-1 6
Thread-3 3
Thread-3 9
Thread-3 10
Thread-1 8
Thread-0 7
Thread-0 11
Thread-0 12
Thread-2 5

四線程共享 tlt 變量，直接修改屬性，數據競爭嚴重，結果不可預期。

山寨版 ThreadLocal：手寫實現驗證核心邏輯

class ThreadLocal<T> {
    private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>());
    protected T initialValue() { return null; }
    public T get() {
        Thread t = Thread.currentThread();
        T obj = map.get(t);
        if (obj == null && !map.containsKey(t)) {
            obj = initialValue();
            map.put(t, obj);
        }
        return obj;
    }
    public void set(T value) { map.put(Thread.currentThread(), value); }
    public void remove() { map.remove(Thread.currentThread()); }
}

運行結果同樣完美實現線程隔離。核心就是 Map<Thread, T> + Thread.currentThread() 作為鍵。

透過現象看本質：為什麼互不影響？

非因使用 Integer（不可變）。關鍵在 initialValue() 和 get()：每個線程調用 get() 發現 Map 無對應條目時，創建新變量（類型 T），各自新建自然互不影響。

為證明本質，將 Integer 換為可變對象 Bean：

public class Bean {
    private String id = "0", name = "none";
    // getter/setter/showinfo...
}

修改 MyThreadLocal 持有 ThreadLocal<Bean>，initialValue() 返回 new Bean()。測試輸出清晰顯示：

• MyThreadLocal 的 tlt 對象確實只有一個（同一哈希碼）
• ThreadLocal 的 tl 對象也只有一個
• 但每個線程獲得的 Bean 對象不同（不同哈希碼），各自操作各自的 Bean 實例

>>:MyThreadLocal{tl=...@1de3f2d}  (四次相同)
Thread-1 Bean@291aff Bean{id='0', name='none'}
Thread-2 Bean@fe64b9 Bean{id='0', name='none'}
Thread-3 Bean@186db54 Bean{id='0', name='none'}
Thread-2 Bean@fe64b9 Bean{id='0', name='none'}  (同一對象)
...

結論：ThreadLocal 變量本身單例，內部維護 Thread → 實例 映射，實現線程級數據隔離。這才是本質！

出處：https://lavasoft.blog.51cto.com/62575/258459