Java中ThreadLocal变量存储类的原理，使用场景及内存泄漏问题

// 每个 thread 对象内部都有一个 threadlocalmap
threadlocal.threadlocalmap threadlocals = null;

// threadlocalmap 内部使用 entry 数组，entry 继承自 weakreference<threadlocal<?>>
static class entry extends weakreference<threadlocal<?>> {
    object value;
    entry(threadlocal<?> k, object v) {
        super(k);  // 弱引用指向 threadlocal 实例
        value = v; // 强引用指向实际存储的值
    }
}

public void set(t value) {
    thread t = thread.currentthread();
    threadlocalmap map = getmap(t);
    if (map != null) {
        map.set(this, value);  // this指当前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：数据库连接管理
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：避免参数传递
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. 导致内存泄漏

// 方案1：手动remove（推荐）
try {
    threadlocal.set(value);
    // ... 业务逻辑
} finally {
    threadlocal.remove();  // 必须执行！
}

// 方案2：使用inheritablethreadlocal（父子线程传递）
threadlocal<string> parent = new inheritablethreadlocal<>();
parent.set("parent value");

new thread(() -> {
    // 子线程可以获取父线程的值
    system.out.println(parent.get());  // "parent value"
}).start();

// 方案3：使用fastthreadlocal（netty优化版）
// 适用于高并发场景，避免了哈希冲突

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
            // 但如果是用完即弃的场景，应该remove
        }
    }

    // 3. 线程池场景必须清理
    public void executeinthreadpool() {
        executorservice executor = executors.newfixedthreadpool(5);

        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                try {
                    usercontext.setuser(new userinfo());
                    // ... 业务处理
                } finally {
                    usercontext.remove();  // 关键！
                }
            });
        }
    }
}

// 查看threadlocalmap内容（调试用）
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));
            }
        }
    }
}