// 每個 Thread 對象內(nèi)部都有一個 ThreadLocalMap
ThreadLocal.ThreadLocalMap threadLocals = null;

// ThreadLocalMap 內(nèi)部使用 Entry 數(shù)組，Entry 繼承自 WeakReference<ThreadLocal<?>>
static class Entry extends WeakReference<ThreadLocal<?>> {
    Object value;
    Entry(ThreadLocal<?> k, Object v) {
        super(k);  // 弱引用指向 ThreadLocal 實例
        value = v; // 強引用指向?qū)嶋H存儲的值
    }
}

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        map.set(this, value);  // this指當(dāng)前ThreadLocal實例
    } else {
        createMap(t, value);
    }
}

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

        // 找到相同的key，直接替換value
        if (k == key) {
            e.value = value;
            return;
        }

        // key已被回收，替換過期條目
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 清理并判斷是否需要擴容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();  // 返回初始值
}

// 場景1：線程上下文信息傳遞（如Spring的RequestContextHolder）
public class RequestContextHolder {
    private static final ThreadLocal<HttpServletRequest> requestHolder = 
    new ThreadLocal<>();

    public static void setRequest(HttpServletRequest request) {
        requestHolder.set(request);
    }

    public static HttpServletRequest getRequest() {
        return requestHolder.get();
    }
}

// 場景2：數(shù)據(jù)庫連接管理
public class ConnectionManager {
    private static ThreadLocal<Connection> connectionHolder = 
    ThreadLocal.withInitial(() -> DriverManager.getConnection(url));

    public static Connection getConnection() {
        return connectionHolder.get();
    }
}

// 場景3：用戶會話信息
public class UserContext {
    private static ThreadLocal<UserInfo> userHolder = new ThreadLocal<>();

    public static void setUser(UserInfo user) {
        userHolder.set(user);
    }

    public static UserInfo getUser() {
        return userHolder.get();
    }
}

// 場景4：避免參數(shù)傳遞
public class TransactionContext {
    private static ThreadLocal<Transaction> transactionHolder = new ThreadLocal<>();

    public static void beginTransaction() {
        transactionHolder.set(new Transaction());
    }

    public static Transaction getTransaction() {
        return transactionHolder.get();
    }
}

強引用鏈：
Thread → ThreadLocalMap → Entry[] → Entry → value (強引用)

                                                   弱引用：
                                                   Entry → key (弱引用指向ThreadLocal)

泄漏場景：
1. ThreadLocal實例被回收 → key=null
2. 但value仍然被Entry強引用
3. 線程池中線程長期存活 → value無法被回收
4. 導(dǎo)致內(nèi)存泄漏

// 方案1：手動remove（推薦）
try {
    threadLocal.set(value);
    // ... 業(yè)務(wù)邏輯
} finally {
    threadLocal.remove();  // 必須執(zhí)行！
}

// 方案2：使用InheritableThreadLocal（父子線程傳遞）
ThreadLocal<String> parent = new InheritableThreadLocal<>();
parent.set("parent value");

new Thread(() -> {
    // 子線程可以獲取父線程的值
    System.out.println(parent.get());  // "parent value"
}).start();

// 方案3：使用FastThreadLocal（Netty優(yōu)化版）
// 適用于高并發(fā)場景，避免了哈希沖突

public class SafeThreadLocalExample {
    // 1. 使用static final修飾
    private static final ThreadLocal<SimpleDateFormat> DATE_FORMAT =
    ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));

    // 2. 包裝為工具類
    public static Date parse(String dateStr) throws ParseException {
        SimpleDateFormat sdf = DATE_FORMAT.get();
        try {
            return sdf.parse(dateStr);
        } finally {
            // 注意：這里通常不需要remove，因為要重用SimpleDateFormat
            // 但如果是用完即棄的場景，應(yīng)該remove
        }
    }

    // 3. 線程池場景必須清理
    public void executeInThreadPool() {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                try {
                    UserContext.setUser(new UserInfo());
                    // ... 業(yè)務(wù)處理
                } finally {
                    UserContext.remove();  // 關(guān)鍵！
                }
            });
        }
    }
}

// 查看ThreadLocalMap內(nèi)容（調(diào)試用）
public static void dumpThreadLocalMap(Thread thread) throws Exception {
    Field field = Thread.class.getDeclaredField("threadLocals");
    field.setAccessible(true);
    Object map = field.get(thread);

    if (map != null) {
        Field tableField = map.getClass().getDeclaredField("table");
        tableField.setAccessible(true);
        Object[] table = (Object[]) tableField.get(map);

        for (Object entry : table) {
            if (entry != null) {
                Field valueField = entry.getClass().getDeclaredField("value");
                valueField.setAccessible(true);
                System.out.println("Key: " + ((WeakReference<?>) entry).get() 
                                   + ", Value: " + valueField.get(entry));
            }
        }
    }
}