CtrlCVer

# ThreadLocal

# ThreadLocal定义

ThreadLocal提供线程局部变量。这些变量与正常的变量不同，因为每一个线程在访问ThreadLocal实例的时候（通过其get或set方法）都有自己的、独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态字段，使用它的目的是希望将状态（例如，用户ID或事务ID）与线程关联起来。（这段话说白了就是绑定thread的作用，这样才能初始化不同的threadLocals吗）

# 有图有真相

  1. 这里使用threadLocalMap代☞Thread内部属性threadLocals。
  2. 图中相同颜色白哦是同一个对象
img 
public class ThreadLocalUtil1{
 private static final ThreadLocal<Integer> threadLocal_1=new ThreadLocal<>();
 public static void set();
 public static Integer get();
}
1
2
3
4
5

每个线程拥有自己的ThreadLocal副本，如上图中Thread1，2，3都有自己的ThreadLcoal副本，当你调用threadLocal.set（）方法时，ThreadLoacl会去查询当前Thread中属性ThreadLocals是否为null，如果为null，则初始化一个ThreadLocalMap，其中key就是这个ThreadLocal对象，值为要传进去的值；如果不为null，就直接去添加值。

这样一来虽然每个Thread的threadLocals中的k即ThreadLocal是一样的，但是value是自己线程传进去的值，而且ThreadLocals都是new出来的，自然也就不一样。这样一来就实现了，不同Thread有不同的ThreadLocals，但是对与他们的同一个ThreadLocal: threadLoacl_1确实相同的。

public class ThreadLcoalUtil2{
 private static final ThreadLocal<Integer> threadLoacl_2=new ThreadLoacl<>();
    public static void set();
}
1
2
3
4

当又使用了了ThreadLocalUtil2中的ThreadLocal_2中的set方法时（会先创建变量副本），就判断到了当前线程中的ThreadLocals不为null，那就会

会向threadLocals中添加k为threadLocal_2的k，v，这样一个Thread中的ThreadLocals就含有两个Entry，一个threadLoacl_1，一个ThreadLocal_2, 不同的Thread中threadLocals不同，但是两个k确实相同的，v也是不同的。

# 重要方法源码

//----Thread：----------
public class Thread implements Runnable {
    ThreadLocal.ThreadLocalMap threadLocals = null;
}
1
2
3
4
//-----ThreadLocal-----

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    }

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
//-------ThreadLocalMap
    static class ThreadLocalMap {
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

比如项目中定义了一个类：

public class ThreadLocal1 {
    private static final ThreadLocal<Integer> threadLocal1 = ThreadLocal.withInitial(() -> 1);
    public static void set(Integer value) {
        threadLocal1.set(value);
    };
    public static Integer get() {
        return threadLocal1.get();
    };
}
1
2
3
4
5
6
7
8
9

同一个线程中多次调用set()方法，值会覆盖，因对k即ThreadLocal是同一个，你可以在河川构建一个ThreadLocal2类，这样就能传两个Entry，或者将value类型改为Map。

# ThreadLocal内存泄漏问题

# 内存泄露

不会再被使用的对象或者变量一直占用内存且不能被回收。占着cs不ls的行为

# 问题原因

ThreadLocalMap中的key是弱引用类型（value可不是），见上文源码

# 关系

image-20231217193940047

每个Thread对象维护着一个ThreadLocalMap的引用 ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储 调用ThreadLocal的set()方法时，实际上就是往ThreadLocalMap设置值，key是ThreadLocal对象，值Value是传递进来的对象 调用ThreadLocal的get()方法时，实际上就是往ThreadLocalMap获取值，key是ThreadLocal对象 ThreadLocal本身并不存储值，它只是自己作为一个key来让线程从ThreadLocalMap获取value，正因为这个原理，所以ThreadLocal能够实现“数据隔离”，获取当前线程的局部变量值，不受其他线程影响

# 弱引用的好处

image-20231217194046032 
public void function01()
{
    ThreadLocal tl = new ThreadLocal<Integer>();    //line1
    tl.set(2021);                                   //line2
    tl.get();                                       //line3
}
1
2
3
4
5
6

当function01方法执行完毕后，栈帧销毁强引用 tl 也就没有了。但此时线程的ThreadLocalMap里某个entry的key引用还指向这个对象 若这个key引用是强引用，就会导致key指向的ThreadLocal对象及v指向的对象不能被gc回收，造成内存泄漏； 若这个key引用是弱引用就大概率会减少内存泄漏的问题(还有一个key为null的雷)。使用弱引用，就可以使ThreadLocal对象在方法执行完毕后顺利被回收且Entry的key引用指向为null。某线程就是指调用这个方法的线程。

此后我们调用get,set或remove方法时，就会尝试删除key为null的entry，可以释放value对象所占用的内存。

1 当我们为threadLocal变量赋值，实际上就是当前的Entry(threadLocal实例为key，值为value)往这个threadLocalMap中存放。Entry中的key是弱引用，当threadLocal外部强引用被置为null(tl=null),那么系统 GC 的时候，根据可达性分析，这个threadLocal实例就没有任何一条链路能够引用到它，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。

2当然，如果当前thread运行结束，threadLocal，threadLocalMap,Entry没有引用链可达，在垃圾回收的时候都会被系统进行回收。

3 但在实际使用中我们有时候会用线程池去维护我们的线程，比如在Executors.newFixedThreadPool()时创建线程的时候，为了复用线程是不会结束的，因为线程池中的线程是重复使用的，意味着这个线程的ThreadLocalMap对象也是重复使用的，如果我们不手动调用remove方法，那么后面的线程就有可能获取到上个线程遗留下来的value值，造成bug。

# 总结

  1. ThreadLocal 并不解决线程间共享数据的问题，
  2. ThreadLocal 适用于变量在线程间隔离且在方法间共享的场景
  3. ThreadLocal 通过隐式的在不同线程内创建独立实例副本避免了实例线程安全的问题
  4. 每个线程持有一个只属于自己的专属Map并维护了ThreadLocal对象与具体实例的映射， 该Map由于只被持有它的线程访问，故不存在线程安全以及锁的问题
  5. ThreadLocalMap的Entry对ThreadLocal的引用为弱引用，避免了ThreadLocal对象无法被回收的问题
  6. set，get，remove都会通过expungeStaleEntry，cleanSomeSlots,replaceStaleEntry这三个方法回收键为 null 的 Entry 对象的值（即为具体实例）以及 Entry 对象本身从而防止内存泄漏，属于安全加固的方法

总而言之，Thread就是借助ThreadLocal new了一个ThreadLocalMap赋值给了Thread的threadLocals变量，所以说每个Thread中存储的值不一样，new的对象肯定不一样啊，这个副本倒不如说成是threadLocals的初始化，感觉这个ThraedLocal就是一个工厂，你调用就相当于给出原材料ThreadLocal，然后它给你创造出了一个产品：threadLocals给你。每个Thread都访问这个工厂，但是获得的产品序列号却不一样；同样的这个工厂可能不止这一个，你可以去不同的工厂加工。

# 附

SimpleDataFormat线程不安全。

ThreadLocalMap与弱引用有关，面试回答弱引用可以插一下ThreadLocalMap，回答ThreadLocalMap可以查一下几种引用。

← Volatile关键字 →