ThreadLocal ⭐⭐

// 共享变量模式：所有线程操作同一个 StringBuilder
// 需要加锁保护
StringBuilder sharedBuilder = new StringBuilder(); // 只有一个实例
 
// ThreadLocal 模式：每个线程拥有自己的 StringBuilder
// 完全不需要任何同步
ThreadLocal<StringBuilder> localBuilder = ThreadLocal.withInitial(StringBuilder::new);
// Thread-1 调用 localBuilder.get() → 得到 Thread-1 专属的 StringBuilder
// Thread-2 调用 localBuilder.get() → 得到 Thread-2 专属的 StringBuilder（另一个实例）

public class UserContext {
 
    // 每个处理请求的线程，都有自己独立的 currentUser 副本
    private static final ThreadLocal<User> currentUser = new ThreadLocal<>();
 
    // 在请求进入时（如 Filter/Interceptor）设置
    public static void set(User user) {
        currentUser.set(user);             // 存入当前线程的副本
    }
 
    // 在业务代码的任何地方获取
    public static User get() {
        return currentUser.get();          // 从当前线程的副本中取出
    }
 
    // 在请求结束时清理，防止内存泄漏（后面详细讲）
    public static void clear() {
        currentUser.remove();              // 移除当前线程的副本
    }
}

public class ConnectionManager {
 
    // 每个线程持有自己的数据库连接
    private static final ThreadLocal<Connection> connectionHolder = new ThreadLocal<>();
 
    public static Connection getConnection() throws SQLException {
        Connection conn = connectionHolder.get();  // 尝试获取当前线程的连接
        if (conn == null) {                        // 如果还没有连接
            conn = dataSource.getConnection();     // 从连接池获取一个新连接
            connectionHolder.set(conn);            // 绑定到当前线程
        }
        return conn;                               // 返回当前线程专属的连接
    }
 
    public static void releaseConnection() throws SQLException {
        Connection conn = connectionHolder.get();  // 获取当前线程的连接
        if (conn != null) {
            conn.close();                          // 归还到连接池
            connectionHolder.remove();             // 从 ThreadLocal 中移除
        }
    }
}

public class DateUtils {
 
    // 每个线程独享一个 SimpleDateFormat 实例，避免并发问题
    private static final ThreadLocal<SimpleDateFormat> dateFormat =
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        // withInitial 指定初始化工厂，首次 get() 时自动创建
 
    public static String format(Date date) {
        return dateFormat.get().format(date);  // 获取当前线程的 formatter 并格式化
    }
 
    public static Date parse(String str) throws ParseException {
        return dateFormat.get().parse(str);    // 获取当前线程的 formatter 并解析
    }
}

// java.lang.Thread 类中的成员变量（简化展示）
public class Thread implements Runnable {
 
    // 每个线程对象都拥有自己的 ThreadLocalMap
    // 这就是 ThreadLocal 数据实际存储的地方！
    ThreadLocal.ThreadLocalMap threadLocals = null;
 
    // 用于 InheritableThreadLocal 的继承机制（后面章节详解）
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
}

public class ThreadIsolationDemo {
 
    // 声明一个 ThreadLocal 变量，所有线程共享这个 ThreadLocal "钥匙"
    private static final ThreadLocal<String> context = new ThreadLocal<>();
 
    public static void main(String[] args) throws InterruptedException {
 
        // 主线程设置值
        context.set("MainThread-Value");                   // 主线程的副本
        System.out.println("[Main] 设置后: " + context.get()); // 输出: MainThread-Value
 
        // 启动子线程 A
        Thread threadA = new Thread(() -> {
            System.out.println("[A] 初始值: " + context.get()); // 输出: null（子线程有自己的副本，未初始化）
            context.set("ThreadA-Value");                       // 设置 A 的副本
            System.out.println("[A] 设置后: " + context.get()); // 输出: ThreadA-Value
        }, "Thread-A");
 
        // 启动子线程 B
        Thread threadB = new Thread(() -> {
            System.out.println("[B] 初始值: " + context.get()); // 输出: null（B 的副本也是独立的）
            context.set("ThreadB-Value");                       // 设置 B 的副本
            System.out.println("[B] 设置后: " + context.get()); // 输出: ThreadB-Value
        }, "Thread-B");
 
        threadA.start();  // 启动 A
        threadB.start();  // 启动 B
        threadA.join();   // 等待 A 完成
        threadB.join();   // 等待 B 完成
 
        // 回到主线程检查：主线程的值完全不受影响
        System.out.println("[Main] 最终值: " + context.get()); // 输出: MainThread-Value
 
        context.remove(); // 最佳实践：用完后 remove
    }
}

[Main] 设置后: MainThread-Value
[A] 初始值: null
[A] 设置后: ThreadA-Value
[B] 初始值: null
[B] 设置后: ThreadB-Value
[Main] 最终值: MainThread-Value

// ❌ 危险示例：所有线程共享同一个 List 实例
List<String> sharedList = new ArrayList<>();            // 创建一个共享的 List
ThreadLocal<List<String>> tl = new ThreadLocal<>();
 
// Thread-1
tl.set(sharedList);          // Thread-1 的副本指向 sharedList
tl.get().add("from-T1");     // 修改的是 sharedList 本身
 
// Thread-2
tl.set(sharedList);          // Thread-2 的副本也指向同一个 sharedList！
tl.get().add("from-T2");     // 修改的还是同一个 sharedList
 
// 两个线程的 "副本" 指向同一个对象，隔离名存实亡！

// ✅ 正确做法：每个线程创建自己的 List 实例
ThreadLocal<List<String>> tl = ThreadLocal.withInitial(ArrayList::new);
// withInitial 保证每个线程首次 get() 时创建一个全新的 ArrayList 实例
// Thread-1 的 List 和 Thread-2 的 List 是两个不同的对象

ExecutorService pool = Executors.newFixedThreadPool(1);     // 只有 1 个线程的线程池
 
ThreadLocal<String> userContext = new ThreadLocal<>();
 
// 第一个任务：模拟用户 Alice 的请求
pool.execute(() -> {
    userContext.set("Alice");                                 // 设置为 Alice
    System.out.println("Task1: " + userContext.get());       // 输出: Alice
    // ❌ 忘记 remove！任务结束，但线程不销毁，数据残留！
});
 
// 第二个任务：模拟用户 Bob 的请求
pool.execute(() -> {
    // 期望是 null（新请求尚未设置），但实际可能是 "Alice"！
    System.out.println("Task2: " + userContext.get());       // 输出: Alice（数据泄漏！）
    // 这是一个严重的安全隐患：Bob 看到了 Alice 的数据
});

public class ThreadLocalSetDemo {
 
    // 声明一个 ThreadLocal 变量，泛型为 String
    // 这个 ThreadLocal 实例本身是共享的（通常是 static final），
    // 但它里面存的值是每个线程各自独立的
    private static final ThreadLocal<String> userName = new ThreadLocal<>();
 
    public static void main(String[] args) {
 
        // ===== 线程 A =====
        Thread threadA = new Thread(() -> {
            userName.set("Alice");                          // 把 "Alice" 写入线程 A 的 Map
            System.out.println("A: " + userName.get());    // 输出: A: Alice
        }, "Thread-A");
 
        // ===== 线程 B =====
        Thread threadB = new Thread(() -> {
            userName.set("Bob");                            // 把 "Bob" 写入线程 B 的 Map
            System.out.println("B: " + userName.get());    // 输出: B: Bob
        }, "Thread-B");
 
        threadA.start();
        threadB.start();
    }
}

// ThreadLocal.set() 简化源码
public void set(T value) {
    Thread t = Thread.currentThread();           // 第1步：获取当前线程对象
    ThreadLocalMap map = getMap(t);              // 第2步：拿到该线程的 ThreadLocalMap
    if (map != null) {
        map.set(this, value);                    // 第3步：以「this（当前 ThreadLocal 实例）」为 Key，存入 value
    } else {
        createMap(t, value);                     // 如果 Map 还不存在，先创建再存
    }
}
 
// getMap 方法：直接返回线程对象上的 threadLocals 字段
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;                       // ThreadLocalMap 挂在 Thread 对象上！
}
 
// createMap 方法：首次使用时初始化
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);  // 创建新 Map 并存入第一个键值对
}

┌───────────────────────────────────────────────────────────────┐
│  Thread-A 的 ThreadLocalMap                                    │
│  ┌──────────────────┬──────────────────┬───────────────────┐  │
│  │   Entry[i]       │   Entry[j]       │   Entry[k]        │  │
│  │   Key: userName  │   Key: traceId   │   Key: formatter  │  │
│  │   Val: "Alice"   │   Val: "T-001"   │   Val: sdf实例    │  │
│  └──────────────────┴──────────────────┴───────────────────┘  │
├───────────────────────────────────────────────────────────────┤
│  Thread-B 的 ThreadLocalMap                                    │
│  ┌──────────────────┬──────────────────┬───────────────────┐  │
│  │   Entry[i]       │   Entry[j]       │   Entry[k]        │  │
│  │   Key: userName  │   Key: traceId   │   Key: formatter  │  │
│  │   Val: "Bob"     │   Val: "T-002"   │   Val: sdf实例    │  │
│  └──────────────────┴──────────────────┴───────────────────┘  │
└───────────────────────────────────────────────────────────────┘

// ThreadLocal.get() 简化源码
public T get() {
    Thread t = Thread.currentThread();               // 第1步：获取当前线程
    ThreadLocalMap map = getMap(t);                  // 第2步：拿到该线程的 ThreadLocalMap
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this); // 第3步：以 this 为 Key 查找
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T) e.value;                  // 命中！返回 Value
            return result;
        }
    }
    return setInitialValue();                        // 未命中，走初始化逻辑
}

// ThreadLocal 默认的 initialValue 实现
protected T initialValue() {
    return null;   // 默认返回 null —— 如果你没覆写，首次 get() 就是 null
}

private static final ThreadLocal<List<String>> buffer = new ThreadLocal<>();
 
public void process() {
    // ❌ 首次 get() 返回 null，直接调用 add() 会 NullPointerException！
    buffer.get().add("data");
}

// ThreadLocal.remove() 简化源码
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread()); // 获取当前线程的 Map
    if (m != null) {
        m.remove(this);                                // 从 Map 中删除以 this 为 Key 的 Entry
    }
}

// 🔥 线程池场景下不 remove 的严重后果
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class DirtyReadDemo {
 
    // 存储当前请求的用户ID
    private static final ThreadLocal<String> currentUser = new ThreadLocal<>();
 
    public static void main(String[] args) {
        // 创建只有 1 个线程的线程池（方便复现问题）
        ExecutorService pool = Executors.newSingleThreadExecutor();
 
        // ===== 任务 A：模拟用户 Alice 的请求 =====
        pool.submit(() -> {
            currentUser.set("Alice");                       // 设置用户为 Alice
            System.out.println("任务A: " + currentUser.get()); // 输出: 任务A: Alice
            // ❌ 忘记 remove()!
        });
 
        // ===== 任务 B：模拟用户 Bob 的请求 =====
        pool.submit(() -> {
            // 期望: 还没 set，应该是 null
            // 实际: 因为线程被复用，读到了 Alice 的数据！💀
            System.out.println("任务B: " + currentUser.get()); // 输出: 任务B: Alice ← 脏读！
        });
 
        pool.shutdown();
    }
}

private static final ThreadLocal<UserContext> userCtx = new ThreadLocal<>();
 
public void handleRequest(HttpServletRequest request) {
    try {
        // ===== 进入阶段：set =====
        UserContext ctx = extractUserContext(request);   // 从请求中提取用户上下文
        userCtx.set(ctx);                               // 存入 ThreadLocal
 
        // ===== 业务逻辑阶段：get =====
        doBusinessLogic();                              // 业务代码中随时 userCtx.get()
        callServiceA();                                 // 深层调用也能 get() 到
        callServiceB();
 
    } finally {
        // ===== 离开阶段：remove（必须！）=====
        userCtx.remove();                               // ⚡ 无论是否异常，都要 remove
    }
}

// 通过匿名内部类覆写 initialValue 方法
private static final ThreadLocal<SimpleDateFormat> formatter =
        new ThreadLocal<SimpleDateFormat>() {
            @Override
            protected SimpleDateFormat initialValue() {
                // 每个线程第一次调用 get() 时执行此方法
                // 返回值会被自动存入当前线程的 ThreadLocalMap
                return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            }
        };
 
public static String formatNow() {
    // 第一次调用：触发 initialValue()，创建 SimpleDateFormat 并缓存
    // 后续调用：直接从 Map 中取出缓存的实例，不再创建
    return formatter.get().format(new Date());
}

// 使用 withInitial + Lambda 表达式（更简洁）
private static final ThreadLocal<SimpleDateFormat> formatter =
        ThreadLocal.withInitial(                         // 工厂方法
            () -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")  // Supplier 函数式接口
        );

// ThreadLocal.withInitial 源码
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
    return new SuppliedThreadLocal<>(supplier);          // 返回一个子类实例
}
 
// SuppliedThreadLocal 内部类
static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
    private final Supplier<? extends T> supplier;        // 持有 Supplier 引用
 
    SuppliedThreadLocal(Supplier<? extends T> supplier) {
        this.supplier = Objects.requireNonNull(supplier); // Supplier 不能为 null
    }
 
    @Override
    protected T initialValue() {
        return supplier.get();                           // 调用 Supplier 来生成初始值
    }
}

private static final ThreadLocal<Integer> counter =
        ThreadLocal.withInitial(() -> 0);              // 初始值 = 0
 
public static void demo() {
    System.out.println(counter.get());   // 0  ← 首次 get，触发 initialValue
    counter.set(42);                     // 修改为 42
    System.out.println(counter.get());   // 42 ← 直接从 Map 取出
    counter.remove();                    // 移除 Entry
    System.out.println(counter.get());   // 0  ← 再次触发 initialValue！重新得到初始值
}

import java.util.UUID;
 
/**
 * 请求追踪上下文工具类
 * 利用 ThreadLocal 在整条调用链中传递 traceId，无需通过方法参数层层传递
 */
public class TraceContext {
 
    // 每个线程首次 get 时自动生成一个 UUID 作为 traceId
    private static final ThreadLocal<String> traceId =
            ThreadLocal.withInitial(() -> UUID.randomUUID().toString().replace("-", ""));
 
    /** 获取当前线程的 traceId */
    public static String getTraceId() {
        return traceId.get();                          // 直接 get，首次会自动初始化
    }
 
    /** 手动设置 traceId（通常在接收上游传递的 traceId 时使用） */
    public static void setTraceId(String id) {
        traceId.set(id);                               // 覆盖 initialValue 产生的值
    }
 
    /** 清理（在请求结束时必须调用） */
    public static void clear() {
        traceId.remove();                              // 防止线程池场景下的脏读和内存泄漏
    }
}
 
/**
 * 模拟 Web 请求处理
 */
public class RequestHandler {
 
    public void handle(String incomingTraceId) {
        try {
            // ===== 请求入口：设置 traceId =====
            if (incomingTraceId != null) {
                TraceContext.setTraceId(incomingTraceId);  // 接收上游的 traceId
            }
            // 如果 incomingTraceId 为 null，调用 getTraceId() 时会自动生成
 
            // ===== 业务逻辑：任何层级都能拿到 traceId =====
            System.out.println("[Handler] traceId=" + TraceContext.getTraceId());
            serviceA();
 
        } finally {
            // ===== 请求出口：必须清理 =====
            TraceContext.clear();                         // ⚡ finally 中 remove
        }
    }
 
    private void serviceA() {
        // 无需传参，直接 get
        System.out.println("[ServiceA] traceId=" + TraceContext.getTraceId());
        repositoryB();
    }
 
    private void repositoryB() {
        // 深层调用同样能拿到同一个 traceId
        System.out.println("[RepoB] traceId=" + TraceContext.getTraceId());
    }
}

private static final ThreadLocal<Integer> tl = ThreadLocal.withInitial(() -> 1);
 
pool.submit(() -> {
    tl.set(100);
    System.out.println("Task1: " + tl.get());
});
 
pool.submit(() -> {
    System.out.println("Task2: " + tl.get());
});

// java.lang.Thread 源码（精简版）
public class Thread implements Runnable {
 
    // 每个线程对象内部都持有一个 ThreadLocalMap 实例
    // 这个 map 就是该线程所有 ThreadLocal 变量的存储容器
    // 初始值为 null，只有在第一次调用 ThreadLocal.set() 或 get() 时才会创建
    ThreadLocal.ThreadLocalMap threadLocals = null;
 
    // InheritableThreadLocal 使用的 map，后续章节讲解
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
 
    // ... 其他字段
}

// ThreadLocal.set() 源码解析
public void set(T value) {
    // 第一步：获取当前调用线程的 Thread 对象
    Thread t = Thread.currentThread();
 
    // 第二步：获取该线程对象内部的 ThreadLocalMap
    // 注意：这里访问的是 t.threadLocals 字段
    ThreadLocalMap map = getMap(t);
 
    // 第三步：如果 map 已存在，直接以「this」（当前 ThreadLocal 对象）为 Key 存入
    if (map != null) {
        map.set(this, value); // this = 当前 ThreadLocal 实例
    } else {
        // 如果 map 不存在（线程首次使用 ThreadLocal），创建新 map
        createMap(t, value);
    }
}
 
// getMap() 方法极其简单——直接返回线程对象的 threadLocals 字段
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals; // 就这一行！数据在 Thread 对象上
}
 
// createMap() 为该线程创建 ThreadLocalMap 并赋值
void createMap(Thread t, T firstValue) {
    // 创建新的 ThreadLocalMap，以当前 ThreadLocal 为第一个 Key
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

// ThreadLocal.get() 源码解析
public T get() {
    // 获取当前线程
    Thread t = Thread.currentThread();
 
    // 获取当前线程的 ThreadLocalMap
    ThreadLocalMap map = getMap(t);
 
    if (map != null) {
        // 以「this」(当前 ThreadLocal 对象) 为 Key，查找对应的 Entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T) e.value; // 取出 value 并返回
            return result;
        }
    }
 
    // 如果 map 不存在或没找到对应 Entry，返回初始值
    return setInitialValue(); // 内部会调用 initialValue()
}

// ===== 内存引用关系（核心！面试高频考点）=====
//
//  栈 (Stack)                堆 (Heap)
//  ──────────              ─────────────────────────────────
//
//  threadLocalRef  ──────→  ThreadLocal 对象 (Key)
//                                    ↑
//                                    │ 弱引用 (WeakReference)
//                                    │
//  currentThread   ──────→  Thread 对象
//                             │
//                             └──→ threadLocals (ThreadLocalMap)
//                                       │
//                                       └──→ Entry[]  数组
//                                              │
//                                              ├── Entry[3]: Key(WeakRef→TL) → Value
//                                              ├── Entry[7]: Key(WeakRef→TL) → Value
//                                              └── ...
//
//  关键点：Entry 的 Key 是对 ThreadLocal 的「弱引用」
//         Entry 的 Value 是对用户数据的「强引用」

// ThreadLocalMap 的核心结构（简化版源码）
static class ThreadLocalMap {
 
    // Entry 继承自 WeakReference<ThreadLocal<?>>
    // 这是理解内存泄漏问题的关键！下一节详解
    static class Entry extends WeakReference<ThreadLocal<?>> {
        // Entry 持有的 value 就是用户存入的数据
        Object value;
 
        Entry(ThreadLocal<?> k, Object v) {
            super(k);     // 将 ThreadLocal 对象包装为弱引用作为 Key
            value = v;    // Value 是强引用
        }
    }
 
    // 底层存储：Entry 数组（注意不是链表！）
    private Entry[] table;
 
    // 初始容量，必须是 2 的幂（与 HashMap 类似）
    private static final int INITIAL_CAPACITY = 16;
 
    // 当前存储的 Entry 数量
    private int size = 0;
 
    // 扩容阈值（默认为容量的 2/3）
    private int threshold;
}

// ThreadLocalMap 的 set 方法（简化版）
private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
 
    // 第一步：计算初始索引位置
    // threadLocalHashCode 是每个 ThreadLocal 对象创建时分配的唯一哈希值
    // 使用 & (len - 1) 代替 % len（因为 len 是 2 的幂）
    int i = key.threadLocalHashCode & (len - 1);
 
    // 第二步：线性探测 —— 从 i 开始，逐个检查槽位
    for (Entry e = tab[i];
         e != null;                    // 遇到空槽则停止探测
         e = tab[i = nextIndex(i, len)]) { // 移到下一个槽位
 
        // 获取该 Entry 的 Key（通过弱引用的 get() 方法）
        ThreadLocal<?> k = e.get();
 
        // 情况 1：找到了同一个 ThreadLocal 对象 → 更新 value
        if (k == key) {
            e.value = value;
            return;
        }
 
        // 情况 2：Key 已被 GC 回收（弱引用返回 null）→ 替换这个过期 Entry
        if (k == null) {
            replaceStaleEntry(key, value, i); // 清理 + 复用槽位
            return;
        }
 
        // 情况 3：Key 不匹配 → 继续线性探测下一个槽位
    }
 
    // 第三步：找到空槽位，创建新 Entry 并放入
    tab[i] = new Entry(key, value);
    int sz = ++size;
 
    // 尝试清理一些过期 Entry，如果没有可清理的且超过阈值则扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold) {
        rehash(); // 扩容：容量翻倍
    }
}
 
// 下一个索引：环形探测（到末尾后回到 0）
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

// ThreadLocal 类中的哈希值生成机制
public class ThreadLocal<T> {
 
    // 每个 ThreadLocal 实例的哈希值，在构造时确定
    private final int threadLocalHashCode = nextHashCode();
 
    // 全局原子计数器（所有 ThreadLocal 实例共享）
    private static AtomicInteger nextHashCode = new AtomicInteger();
 
    // 黄金比例数（Golden Ratio）相关的魔法常量
    // 0x61c88647 ≈ 2^32 * (1 - 1/φ)，其中 φ 是黄金比例 1.618...
    // 这个值能使哈希值在 2 的幂长度的数组中均匀分布
    private static final int HASH_INCREMENT = 0x61c88647;
 
    // 每创建一个新 ThreadLocal，哈希值就递增一个固定步长
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
}

// 验证 0x61c88647 的均匀分布特性
public class HashDistributionDemo {
    private static final int HASH_INCREMENT = 0x61c88647;
 
    public static void main(String[] args) {
        int n = 16; // 模拟长度为 16 的数组
        int hash = 0;
        for (int i = 0; i < n; i++) {
            hash += HASH_INCREMENT;
            int index = hash & (n - 1); // 计算索引
            System.out.printf("ThreadLocal #%2d → slot[%2d]%n", i, index);
        }
        // 输出结果：每个 slot 恰好被分配一次（完美散列）
        // ThreadLocal # 0 → slot[ 7]
        // ThreadLocal # 1 → slot[14]
        // ThreadLocal # 2 → slot[ 5]
        // ThreadLocal # 3 → slot[12]
        // ThreadLocal # 4 → slot[ 3]
        // ... 完美分布到 0-15 的每一个槽位
    }
}

// ThreadLocalMap.Entry 的完整定义
// 关键：Entry extends WeakReference<ThreadLocal<?>>
// 这意味着 Entry 本身就是一个弱引用对象，引用目标是 ThreadLocal
static class Entry extends WeakReference<ThreadLocal<?>> {
 
    // value 是强引用！这是内存泄漏的根源
    Object value;
 
    Entry(ThreadLocal<?> k, Object v) {
        // super(k) 调用 WeakReference 的构造器
        // 将 ThreadLocal k 包装为弱引用
        // 当外部没有强引用指向 k 时，GC 会回收 k
        // 此时 this.get() 返回 null（Key 变成 null）
        super(k);
 
        // value 用普通强引用持有，不会被 GC 自动回收
        this.value = v;
    }
}

public class SomeService {
 
    public void handleRequest() {
        // 在方法内创建 ThreadLocal（局部变量）
        ThreadLocal<User> userContext = new ThreadLocal<>();
 
        userContext.set(getCurrentUser()); // 存入当前用户
 
        try {
            doBusinessLogic(); // 业务处理，内部通过 userContext 获取用户
        } finally {
            userContext.remove(); // ✅ 最佳实践：用完就 remove
        }
 
        // 方法结束后，局部变量 userContext 出栈
        // 此时栈上已无指向 ThreadLocal 对象的强引用
    }
}

// ThreadLocalMap 的 expungeStaleEntry 方法（简化版）
// 这个方法负责清理一个过期 Entry 及其附近的过期 Entry
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
 
    // 第一步：清理当前过期 Entry
    tab[staleSlot].value = null; // 断开 Value 的强引用 → 允许 GC 回收 Value
    tab[staleSlot] = null;       // 清空 Entry 槽位
    size--;                      // 计数减一
 
    // 第二步：向后探测，连续清理后续的过期 Entry
    // 同时对仍有效的 Entry 进行 rehash（重新散列）以维护探测链
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
 
        ThreadLocal<?> k = e.get(); // 获取弱引用指向的 Key
 
        if (k == null) {
            // Key 已被 GC → 过期条目，清理之
            e.value = null;  // 断开 Value 引用
            tab[i] = null;   // 清空槽位
            size--;
        } else {
            // Key 仍存活，重新计算位置
            // 如果当前位置不是理想位置，则搬移到更近的空槽
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;
                while (tab[h] != null) {
                    h = nextIndex(h, len);
                }
                tab[h] = e;
            }
        }
    }
    return i;
}

// 弱引用 Key 的「半解决」困境
//
// GC 前:
//   Entry →  Key (WeakRef → ThreadLocal)  ✓ 弱引用
//            Value (StrongRef → UserData)  ✗ 强引用
//
// GC 后:
//   Entry →  Key = null     (ThreadLocal 已被回收)
//            Value = UserData (仍然存活！无法被 GC 回收)
//
// 结果：ThreadLocal 被回收了，但 Value 还活着 → 内存泄漏！
// 
// 这就是为什么必须调用 remove()，或者依赖 ThreadLocalMap 的
// 被动清理机制（在 get/set 时顺带清理 stale entry）

// 启发式清理：对数级采样扫描
// 参数 i 是刚插入 Entry 的位置，n 是当前 size
private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
 
    // 扫描 log2(n) 个槽位（平衡清理效率与性能开销）
    do {
        i = nextIndex(i, len); // 移动到下一个槽位
        Entry e = tab[i];
        if (e != null && e.get() == null) {
            // 发现过期 Entry！
            n = len;           // 重置扫描次数（发现一个就多扫几轮）
            removed = true;
            i = expungeStaleEntry(i); // 执行连续清理
        }
    } while ((n >>>= 1) != 0); // n 右移一位，即 log2(n) 次循环
 
    return removed; // 返回是否有清理发生
}

static final ThreadLocal<List<String>> CACHE = new ThreadLocal<>();
 
public void process() {
    CACHE.set(new ArrayList<>());
    CACHE.get().add("data-1");
    CACHE.get().add("data-2");
    // 注意：没有调用 CACHE.remove()
}

// ThreadLocalMap 的 Entry 定义（JDK 源码简化版）
// 注意：Entry 继承自 WeakReference<ThreadLocal<?>>
static class Entry extends WeakReference<ThreadLocal<?>> {
 
    // Value 是强引用，直接持有业务对象
    Object value;
 
    Entry(ThreadLocal<?> k, Object v) {
        // 调用 WeakReference 的构造函数，将 ThreadLocal 对象包装为弱引用
        // 这意味着：如果外部没有任何强引用指向这个 ThreadLocal，GC 时它会被回收
        super(k);
        // Value 则是普通的强引用赋值
        // 只要 Entry 对象存活，Value 就不会被 GC 回收
        value = v;
    }
}

public class LeakDemo {
 
    public void process() {
        // 步骤 1：在方法内部创建 ThreadLocal（局部变量）
        ThreadLocal<byte[]> localCache = new ThreadLocal<>();
 
        // 步骤 2：set 一个大对象作为 Value
        localCache.set(new byte[10 * 1024 * 1024]); // 10MB 的字节数组
 
        // 步骤 3：使用完毕后...直接返回，没有调用 remove()
        // localCache 是局部变量，方法返回后，栈帧销毁
        // → localCache 这个强引用消失
        // → ThreadLocal 对象仅剩 Entry 中的弱引用指向它
    }
    // 方法结束后，localCache 出栈 → ThreadLocal 对象只剩弱引用
    // 下次 GC 时，ThreadLocal 对象被回收 → Entry.key 变为 null
    // 但 Entry.value（10MB byte[]）仍然被强引用持有！
    // 这 10MB 就泄漏了！
}

// ===== GC 后 ThreadLocalMap 内部的 table 数组状态 =====
//
// ThreadLocalMap.table (Entry[])
// ┌─────────┬──────────────────────────────────────────────┐
// │ index   │ Entry                                        │
// ├─────────┼──────────────────────────────────────────────┤
// │  0      │ null                                         │
// │  1      │ Entry { key=WeakRef→TL_A(存活), value=obj1 } │  ← 正常 Entry
// │  2      │ null                                         │
// │  3      │ Entry { key=WeakRef→null,  value=10MB!! }    │  ← ⚠️ 幽灵 Entry!
// │  4      │ Entry { key=WeakRef→TL_B(存活), value=obj2 } │  ← 正常 Entry
// │  5      │ null                                         │
// │  ...    │ ...                                          │
// └─────────┴──────────────────────────────────────────────┘
//
// index=3 的 Entry：Key 已被 GC 回收（弱引用指向 null）
// 但 Value（10MB byte[]）仍被 Entry 强引用，无法回收
// 这就是内存泄漏！

// ===== ThreadLocalMap 中的清理逻辑（JDK 源码简化版）=====
 
// 在 set() 操作中，遍历 table 寻找插入位置时，顺带清理幽灵 Entry
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(); // 获取 Entry 的 Key（通过弱引用的 get()）
 
        if (k == key) {
            // Key 匹配：更新 Value
            e.value = value;
            return;
        }
 
        if (k == null) {
            // ⚡ 发现幽灵 Entry（key 已被 GC 回收）
            // 调用 replaceStaleEntry 清理这个位置，并将新值放在这里
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // ... 创建新 Entry 的逻辑
}
 
// expungeStaleEntry：清理指定位置的幽灵 Entry
// 这个方法会从 staleSlot 开始，向后连续扫描并清理所有 key==null 的 Entry
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
 
    // 第一步：清理当前幽灵 Entry
    tab[staleSlot].value = null;  // 断开 Value 的强引用 → GC 可回收
    tab[staleSlot] = null;        // 清除 Entry 引用 → Entry 本身也可回收
    size--;                       // 元素计数减一
 
    // 第二步：继续向后扫描，清理连续段中的所有幽灵 Entry
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {
            // 又发现一个幽灵 Entry，清理之
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            // 正常 Entry：重新哈希，确保线性探测的正确性
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;
                while (tab[h] != null) h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

// ===== 线程池环境下 ThreadLocal 泄漏的典型场景 =====
public class PoolLeakDemo {
 
    // 线程池：核心线程长期存活，不会被销毁
    private static final ExecutorService pool = Executors.newFixedThreadPool(10);
 
    public static void main(String[] args) {
        // 模拟高并发场景：反复提交任务
        for (int i = 0; i < 100_000; i++) {
            pool.execute(() -> {
                // 每次任务都创建一个新的 ThreadLocal 并 set 大对象
                ThreadLocal<byte[]> tl = new ThreadLocal<>();
                tl.set(new byte[1024 * 1024]); // 1MB
 
                // ... 业务逻辑 ...
 
                // ❌ 没有调用 tl.remove()!
                // 任务结束后，tl 局部变量出栈，ThreadLocal 对象仅剩弱引用
                // GC 后 → Entry.key = null，但 Entry.value（1MB）仍然残留
                // 线程不会死亡 → ThreadLocalMap 不会被回收
                // 反复积累 → 内存持续增长 → 最终 OOM!
            });
        }
    }
}

// ===== ThreadLocal.remove() 的源码逻辑（简化版）=====
public void remove() {
    // 获取当前线程的 ThreadLocalMap
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null) {
        // 从 Map 中删除以当前 ThreadLocal 为 Key 的 Entry
        m.remove(this);
    }
}
 
// ThreadLocalMap.remove() 的实现
private void remove(ThreadLocal<?> key) {
    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)]) {
        if (e.get() == key) {      // 找到目标 Entry
            e.clear();              // 清除弱引用（Key → null）
            expungeStaleEntry(i);   // 清理该位置的 Entry（Value 也被清除）
            return;
        }
    }
}

// ===== ThreadLocal 的正确使用模式：try-finally =====
public class CorrectUsageDemo {
 
    // 通常将 ThreadLocal 声明为 static final，全局复用同一个实例
    // 这样所有线程共享同一个 ThreadLocal 对象作为 Key，但各自有独立的 Value
    private static final ThreadLocal<UserContext> USER_CONTEXT = new ThreadLocal<>();
 
    public void handleRequest(HttpServletRequest request) {
        try {
            // ========== 1. SET：在业务开始时设置线程本地变量 ==========
            UserContext ctx = extractUserFromRequest(request);
            USER_CONTEXT.set(ctx);  // 将用户上下文存入当前线程的 ThreadLocalMap
 
            // ========== 2. USE：在业务链路的任意位置获取 ==========
            processOrder();    // 内部可通过 USER_CONTEXT.get() 获取用户信息
            sendNotification();// 同样可以获取，无需参数传递
 
        } finally {
            // ========== 3. REMOVE：在业务结束时必须清理 ==========
            // 无论业务逻辑是否抛异常，finally 块一定会执行
            USER_CONTEXT.remove();  // 彻底删除 Entry，防止内存泄漏
        }
    }
 
    private void processOrder() {
        // 在调用链的深层方法中，直接获取线程本地变量
        UserContext ctx = USER_CONTEXT.get();
        System.out.println("处理订单，当前用户: " + ctx.getUserName());
    }
 
    private void sendNotification() {
        UserContext ctx = USER_CONTEXT.get();
        System.out.println("发送通知给: " + ctx.getEmail());
    }
}

// ===== 安全的 ThreadLocal 工具类封装 =====
public final class ThreadLocalUtil {
 
    private ThreadLocalUtil() {} // 禁止实例化
 
    /**
     * 安全地执行带有 ThreadLocal 上下文的操作
     * 使用函数式编程风格，自动管理 set/remove 生命周期
     *
     * @param threadLocal  要操作的 ThreadLocal 实例
     * @param value        要设置的值
     * @param action       需要在 ThreadLocal 上下文中执行的业务逻辑
     * @param <T>          ThreadLocal 存储的值类型
     */
    public static <T> void executeWithContext(
            ThreadLocal<T> threadLocal,
            T value,
            Runnable action) {
 
        // 设置值
        threadLocal.set(value);
        try {
            // 执行业务逻辑
            action.run();
        } finally {
            // 无论如何都要清理，彻底杜绝泄漏
            threadLocal.remove();
        }
    }
 
    /**
     * 带返回值的版本
     */
    public static <T, R> R computeWithContext(
            ThreadLocal<T> threadLocal,
            T value,
            Supplier<R> supplier) {
 
        threadLocal.set(value);
        try {
            return supplier.get();
        } finally {
            threadLocal.remove();
        }
    }
}

// ===== 使用工具类，自动管理生命周期 =====
ThreadLocalUtil.executeWithContext(
    USER_CONTEXT,                                     // ThreadLocal 实例
    new UserContext("张三", "zhangsan@example.com"),   // 要设置的值
    () -> {                                            // 业务逻辑（Lambda）
        processOrder();
        sendNotification();
    }
    // 方法返回时，remove() 已被自动调用，无需手动管理
);

// ===== 自清理线程池：任务完成后自动清理 ThreadLocal =====
public class CleaningThreadPoolExecutor extends ThreadPoolExecutor {
 
    // 记录每个线程池需要管理的 ThreadLocal 实例
    private final List<ThreadLocal<?>> managedThreadLocals;
 
    public CleaningThreadPoolExecutor(
            int corePoolSize, int maximumPoolSize,
            long keepAliveTime, TimeUnit unit,
            BlockingQueue<Runnable> workQueue,
            List<ThreadLocal<?>> managedThreadLocals) {
 
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        // 保存需要管理的 ThreadLocal 列表
        this.managedThreadLocals = Collections.unmodifiableList(managedThreadLocals);
    }
 
    /**
     * afterExecute 钩子：每个任务执行完毕后自动调用
     * 在这里清理所有被管理的 ThreadLocal，作为安全网
     */
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
 
        // 遍历所有被管理的 ThreadLocal，逐个 remove
        for (ThreadLocal<?> tl : managedThreadLocals) {
            tl.remove();  // 确保每个 ThreadLocal 都被清理
        }
 
        // 如果任务抛出了异常，记录日志
        if (t != null) {
            log.error("任务执行异常，ThreadLocal 已清理", t);
        }
    }
}

// ===== 终极方案：通过反射强制清空 ThreadLocalMap =====
// ⚠️ 慎用！仅在确实无法控制 ThreadLocal 生命周期时使用
public class ThreadLocalCleaner {
 
    /**
     * 清空当前线程的所有 ThreadLocal 数据
     * 原理：通过反射获取 Thread.threadLocals 字段，将其设为 null
     */
    public static void clearAll() {
        try {
            // 获取 Thread 类中的 threadLocals 字段（private）
            Field threadLocalsField = Thread.class.getDeclaredField("threadLocals");
            threadLocalsField.setAccessible(true);  // 突破访问控制
 
            // 将当前线程的 threadLocals 字段置为 null
            // 这会导致整个 ThreadLocalMap 失去引用，GC 时被完整回收
            threadLocalsField.set(Thread.currentThread(), null);
 
        } catch (NoSuchFieldException | IllegalAccessException e) {
            // 不同 JDK 版本字段名可能不同，或高版本 JDK 模块化限制
            log.warn("清理 ThreadLocal 失败", e);
        }
    }
}

ExecutorService pool = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10000; i++) {
    pool.execute(() -> {
        ThreadLocal<List<String>> tl = new ThreadLocal<>();
        tl.set(new ArrayList<>(Arrays.asList("a", "b", "c")));
        System.out.println(tl.get());
    });
}

public class InheritableThreadLocalDemo {
    // 使用 InheritableThreadLocal 而非 ThreadLocal
    private static final InheritableThreadLocal<String> TRACE_ID =
            new InheritableThreadLocal<>();
 
    public static void main(String[] args) throws InterruptedException {
        // 父线程设置 traceId
        TRACE_ID.set("trace-abc-123");                          // 父线程写入值
        System.out.println("[父线程] traceId = " + TRACE_ID.get()); // 输出: trace-abc-123
 
        // 创建子线程
        Thread child = new Thread(() -> {
            // 子线程自动继承了父线程的值, 无需手动传递!
            System.out.println("[子线程] traceId = " + TRACE_ID.get()); // 输出: trace-abc-123
 
            // 子线程修改自己的副本, 不影响父线程
            TRACE_ID.set("trace-child-999");                    // 子线程写入新值
            System.out.println("[子线程] 修改后 traceId = " + TRACE_ID.get()); // 输出: trace-child-999
        });
 
        child.start();    // 启动子线程
        child.join();     // 等待子线程结束
 
        // 父线程的值不受子线程修改的影响
        System.out.println("[父线程] traceId仍然 = " + TRACE_ID.get()); // 输出: trace-abc-123
    }
}

public class Thread implements Runnable {
    // 普通 ThreadLocal 使用这个 Map
    ThreadLocal.ThreadLocalMap threadLocals = null;           // 存储 ThreadLocal 的值
 
    // InheritableThreadLocal 使用这个 Map
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; // 存储 InheritableThreadLocal 的值
}

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
 
    // 重写 1: 告诉 ThreadLocal 框架 —— 去操作 inheritableThreadLocals 而不是 threadLocals
    ThreadLocalMap getMap(Thread t) {
        return t.inheritableThreadLocals;                     // 返回可继承的 Map
    }
 
    // 重写 2: 如果 Map 不存在, 创建时也创建在 inheritableThreadLocals 上
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals =                           // 在可继承 Map 上创建
            new ThreadLocalMap(this, firstValue);
    }
 
    // 重写 3: 子线程继承时的值转换钩子(默认直接返回原值, 可重写实现自定义转换)
    protected T childValue(T parentValue) {
        return parentValue;                                   // 默认: 子线程直接拿到父线程的值
    }
}

// Thread 构造方法中的核心逻辑(简化版)
private Thread(ThreadGroup g, Runnable target, String name, long stackSize,
               AccessControlContext acc, boolean inheritThreadLocals) {
    // ... 省略其他初始化逻辑 ...
 
    Thread parent = currentThread();                          // 获取当前线程(即父线程)
 
    // ★ 关键继承逻辑 ★
    if (inheritThreadLocals && parent.inheritableThreadLocals != null) {
        // 将父线程的 inheritableThreadLocals 拷贝到子线程
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); // 拷贝!
    }
}

// ThreadLocal.ThreadLocalMap 中的拷贝构造方法(简化版)
private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;                    // 父线程的 Entry 数组
    int len = parentTable.length;                             // 数组长度
    table = new Entry[len];                                   // 子线程创建同等大小的数组
 
    for (Entry e : parentTable) {                             // 遍历父线程的每个 Entry
        if (e != null) {
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get(); // 取出 Key(弱引用)
            if (key != null) {
                Object value = key.childValue(e.value);       // ★ 调用 childValue 获取子线程的值
                Entry c = new Entry(key, value);              // 创建新的 Entry
                int h = key.threadLocalHashCode & (len - 1);  // 计算 hash 槽位
                while (table[h] != null)                      // 线性探测解决冲突
                    h = nextIndex(h, len);
                table[h] = c;                                 // 放入子线程的 Map
                size++;                                       // 计数
            }
        }
    }
}

public class ShallowCopyTrapDemo {
    // 存储一个可变的 List
    private static final InheritableThreadLocal<List<String>> CONTEXT =
            new InheritableThreadLocal<List<String>>() {
                @Override
                protected List<String> initialValue() {
                    return new ArrayList<>();                   // 初始值: 空列表
                }
            };
 
    public static void main(String[] args) throws InterruptedException {
        CONTEXT.get().add("父线程数据");                         // 父线程往 List 中添加元素
        System.out.println("[父线程] " + CONTEXT.get());         // [父线程数据]
 
        Thread child = new Thread(() -> {
            // 子线程继承了父线程的 List —— 但这是同一个 List 对象!
            CONTEXT.get().add("子线程数据");                     // 子线程也往 List 中添加元素
            System.out.println("[子线程] " + CONTEXT.get());     // [父线程数据, 子线程数据]
        });
        child.start();
        child.join();
 
        // ⚠️ 父线程的 List 也被子线程修改了!
        System.out.println("[父线程] " + CONTEXT.get());         // [父线程数据, 子线程数据] ← 被污染!
    }
}

// ==================== 浅拷贝: 父子线程共享同一个 List 对象 ====================
//
//   父线程 ThreadLocalMap                子线程 ThreadLocalMap
//   ┌──────────┐                        ┌──────────┐
//   │ Key: ITL │──value──┐              │ Key: ITL │──value──┐
//   └──────────┘         │              └──────────┘         │
//                        ▼                                   │
//                   ┌─────────────┐                          │
//                   │  ArrayList  │ ◄────────────────────────┘
//                   │ [父线程数据] │    同一个对象! 任何一方修改都互相影响
//                   └─────────────┘

private static final InheritableThreadLocal<List<String>> CONTEXT =
        new InheritableThreadLocal<List<String>>() {
 
            @Override
            protected List<String> initialValue() {
                return new ArrayList<>();                       // 初始值: 空列表
            }
 
            @Override
            protected List<String> childValue(List<String> parentValue) {
                // ★ 深拷贝: 创建新的 ArrayList, 复制父线程的元素
                return new ArrayList<>(parentValue);            // 子线程拿到独立副本
            }
        };

// ==================== 深拷贝: 父子线程各自持有独立的 List ====================
//
//   父线程 ThreadLocalMap                子线程 ThreadLocalMap
//   ┌──────────┐                        ┌──────────┐
//   │ Key: ITL │──value──┐              │ Key: ITL │──value──┐
//   └──────────┘         │              └──────────┘         │
//                        ▼                                   ▼
//                   ┌─────────────┐                    ┌─────────────┐
//                   │  ArrayList  │                    │  ArrayList  │
//                   │ [父线程数据] │                    │ [父线程数据] │ ← 独立副本
//                   └─────────────┘                    └─────────────┘

public class ThreadPoolInheritanceBug {
    private static final InheritableThreadLocal<String> USER_ID =
            new InheritableThreadLocal<>();
 
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(1); // 只有 1 个线程的池
 
        // ====== 第一次请求: 用户 Alice ======
        USER_ID.set("Alice");                                   // 主线程设为 Alice
        pool.submit(() -> {
            // 线程池中的线程第一次被创建, 继承了 Alice
            System.out.println("Task1: " + USER_ID.get());      // 输出: Alice ✅
        }).get();
 
        // ====== 第二次请求: 用户 Bob ======
        USER_ID.set("Bob");                                     // 主线程设为 Bob
        pool.submit(() -> {
            // 线程被复用! 不会重新触发 new Thread(), 不会重新继承!
            System.out.println("Task2: " + USER_ID.get());      // 输出: Alice ❌ (期望 Bob)
        }).get();
 
        pool.shutdown();
    }
}

// 使用 TransmittableThreadLocal (需引入依赖 com.alibaba:transmittable-thread-local)
import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.TtlRunnable;
 
public class TTLDemo {
    private static final TransmittableThreadLocal<String> USER_ID =
            new TransmittableThreadLocal<>();                   // 替换为 TTL
 
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(1);
 
        USER_ID.set("Alice");
        pool.submit(TtlRunnable.get(() -> {                     // 用 TtlRunnable 包装任务
            System.out.println("Task1: " + USER_ID.get());      // Alice ✅
        })).get();
 
        USER_ID.set("Bob");
        pool.submit(TtlRunnable.get(() -> {                     // 每次提交都重新快照
            System.out.println("Task2: " + USER_ID.get());      // Bob ✅ (修复!)
        })).get();
 
        pool.shutdown();
    }
}

public class ManualPassDemo {
    private static final ThreadLocal<String> USER_ID = new ThreadLocal<>(); // 普通 ThreadLocal 即可
 
    // 包装器: 在提交时捕获值, 在执行时恢复值
    static Runnable wrap(Runnable task) {
        String captured = USER_ID.get();                        // 提交时: 捕获当前线程的值
        return () -> {
            USER_ID.set(captured);                              // 执行时: 设置到工作线程
            try {
                task.run();                                     // 执行原始任务
            } finally {
                USER_ID.remove();                               // 执行后: 清理, 防止污染
            }
        };
    }
 
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(1);
 
        USER_ID.set("Alice");
        pool.submit(wrap(() -> {
            System.out.println("Task1: " + USER_ID.get());     // Alice ✅
        })).get();
 
        USER_ID.set("Bob");
        pool.submit(wrap(() -> {
            System.out.println("Task2: " + USER_ID.get());     // Bob ✅
        })).get();
 
        pool.shutdown();
    }
}