第一步先看看ThreadLocal的使用吧！

我几乎是很讨厌使用ThreadLocal的，但是在北京慧摩尔公司待过一段时间，也觉得有点作用。于是深入研究了ThreadLocal，但是一直没实际实践。正好京东项目跟电信对接过程中，有个请求头信息是后期电信追加的。让前端传递不太现实，对接的接口太多了，于是我就在拦截器使用ThreadLocal，然后业务去取的时候，直接拦截器类名.ThreadLocal的变量名.get()。上代码

拦截器伪代码（设置值）

@Component
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {

    public static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        telcomForSetAuth(request);
        return true;
    }

    // 将前端传递的Authorization作为电信使用的auth字段
    private void telcomForSetAuth(HttpServletRequest request) {
        String authorization = request.getHeader("Authorization");
        if (StringUtils.isNotBlank(authorization)) {
            threadLocal.set(authorization);
        }
    }

    private String telcomForGetAuth() {
        return threadLocal.get();
    }

获取值

   // 使用
   String auth = LoginInterceptor.threadLocal.get();

ThreadLocal有啥用？

开辟内存空间为任意线程提供其局部变量，不同线程之间不会相互干扰，这个变量值在线程的生命周期起到作用。

白话就是：我们调用方法可以少传递参数。直接使

ThreadLocal的特点

• 线程并发：多线程并发的场景。
• 传递数据：ThreadLocal在同一线程，不同方法中传递公共变量。
• 线程隔离：每一个线程的私有数据是独立的，多线程之间不会相互影响。

ThreadLocal常用方法

• void set(T value) ：将value与当前线程绑定。
• T get()：获取当前线程绑定的value。
• void remove()

必须记忆：在ThreadLocal的get()、set()、remove()方法调用的时候会清除掉线程ThreadLocalMap中所有Entry中Key为null的Value，并将整个Entry设置为null，利于下次内存回收

原有案例，多个线程共同争抢一个变量element，有线程安全问题

@Data
public class ThreadLocalStudy {
    String element = "";
    public static void main(String[] args) {
        ThreadLocalStudy hw = new ThreadLocalStudy();
        // 开启多个线程，共同操作element
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    hw.setElement(Thread.currentThread().getName());
                    System.out.println(String.format("线程是：%s，value：%s", Thread.currentThread().getName(), hw.getElement()));
                }
            }).start();
        }
    }
}

线程是：Thread-8，value：Thread-8
线程是：Thread-3，value：Thread-3
线程是：Thread-9，value：Thread-9
线程是：Thread-5，value：Thread-5
线程是：Thread-1，value：Thread-0
线程是：Thread-0，value：Thread-0
线程是：Thread-4，value：Thread-4

ThreadLoacal去解决线程不安全

@Data
public class ThreadLocalStudy {
    String element = "";
    static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    public static void main(String[] args) {
        ThreadLocalStudy hw = new ThreadLocalStudy();
        // 开启多个线程，共同操作element
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    threadLocal.set((Thread.currentThread().getName()));
                    System.out.println(String.format("当前线程是%s，value是%s", Thread.currentThread().getName(), threadLocal.get()));
                }
            }).start();
        }
    }
}

synchronized 与 ThreadLocal对比

synchronized虽然也可解决线程安全问题，但是synchronized锁定了后，即便是多个线程，但是线程无法获取锁，也就无法执行，所以synchronized并不是好的方案。

核心对比

synchronized：以时间换空间。让多个线程也要排队访问。

threadlocal：以空间换时间的形式。线程独立，谁访问谁自己的变量。

所以ThreadLocal使得程序拥有更高并发性

ThreadLocal内部结构

JDK8之前，ThreadLocal自己维护一个全局ThreadLocalMap，key存储每一个Thread，Value存放T值。

JDK8 ThreadLocal：每一个线程维护（拥有）一个ThreadLocalMap。这个Map集合的key是ThreadLocal本身，value，才是存储的Object。注意Key<T>是弱引用。

JDK8设计Key=ThreadLocal的好处

Thread类又个成员变量，如果是Key=Thread对象，那么我们一个线程ThreadLocalMap只能存储一个变量对象，如果是ThreaLocal，则可以存储多个对象。

Thread销毁，ThreadLocalMap随之销毁，节省了内存开销。

set方法

先查看ThreadLocalMap是否存在，如果不存在，就创建ThreadLocalMap，然后再放入Thread、T。

get方法：

返回此线程局部变量的当前线程副本中的值。如果变量没有当前线程的值，则首先将其初始化为调用initialValue方法返回的值。

ThreadLocalMap

是ThreadLocal内部类，没有实现Map接口，是完全自己独立实现的。ThreadLocalMap是Thread类的成员变量。

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocalMap内存溢出

Thread类有一个ThreadLocalMap成员变量。该变量包含了一个Entry数组，该数组真正保存了ThreadLocal类set的数据。Entry是由threadLocal和value组成。

我们分析GC引用链强引用链：Thread变量 -> Thread对象 -> ThreadLocalMap -> Entry -> key -> ThreadLocal对象。Thread对象是强引用。我们一般操作是使用线程池来管理Thread对象，就说明线程对象不会被回收，也就一直保存着强引用关系。key，value一直存在，一旦发生GC，没有被强引用所引用就会出现Key被回收掉，但是Value并没有被回收。

static class Entry extends WeakReference<ThreadLocal<?>> 

整体的ThreadLocalMap内存溢出的真实原因

线程与Entity没有同时回收，也就是生命周期不完全一致。

线程回收没有调用ThreadLocal的remove()，最终造成了内存溢出！我们要解决的话，就要在Try catch Finally执行remove()即可。

为啥ThreadLocalMap内存溢出与弱引用无关，还要用弱引用呢？

用强引用，会造成ThreadLocal没及时回收。弱引用可以多一层GC正常回收的保障！当下次get、set、remove的时候，就会触发ThreadLocal的清除机制：key为空，就清除Value，同时将Entry=null。等待下次GC。

ThreadLocal - Hash冲突

JDK8一般就存储一个Key，冲突个鸡毛蛋！

采用线性探测法。

子线程获取主线程数据 - InheritableThreadLocal

原理分析：进入InheritableThreadLocal内容，继承ThreadLocal，重写了三个方法。第一是createMap、getMap。翻翻ThreadLocal的方法。set与get的时候，都会调用getMap方法，由于继承关系，走了方法重写的对象，第一次初始化(creathMap)的时候是延迟创建的，也就是set方法创建的。传参子线程的key是InheritableThreadLocal对象。在createMap的时候调用了创建ThreadLocalMap的方法重载（这个方法仅供对InheritableThreadLocal使用哦）创建的过程中，会检测父类的是否

    public static void main(String[] args) {
        // ThreadLocal<String> stringThreadLocal = new ThreadLocal<>();
        InheritableThreadLocal<String> stringThreadLocal = new InheritableThreadLocal<>();
        stringThreadLocal.set("hello");
        System.out.println(Thread.currentThread().getName() + ":" + stringThreadLocal.get());
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + ":" + stringThreadLocal.get());
        }).start();
    }

结果：

main:hello
Thread-0:hello