浅析ThreadLocal使用及实现原理

1.ThreadLocal是什么

该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其get 或 set方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联 。所以ThreadLocal与线程同步机制不同，线程同步机制是多个线程共享同一个变量，而ThreadLocal是为每一个线程创建一个单独的变量副本，故而每个线程都可以独立地改变自己所拥有的变量副本，而不会影响其他线程所对应的副本。可以这么说ThreadLocal为多线程环境下变量问题提供了另外一种解决思路 。

Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。

ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）。

每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

项目推荐：基于SpringBoot2.x、SpringCloud和SpringCloudAlibaba企业级系统架构底层框架封装，解决业务开发时常见的非功能性需求，防止重复造轮子，方便业务快速开发和企业技术栈框架统一管理。引入组件化的思想实现高内聚低耦合并且高度可配置化，做到可插拔。严格控制包依赖和统一版本管理，做到最少化依赖。注重代码规范和注释，非常适合个人学习和企业使用

Github地址：https://github.com/plasticene/plasticene-boot-starter-parent

Gitee地址：https://gitee.com/plasticene3/plasticene-boot-starter-parent

微信公众号：Shepherd进阶笔记

2.ThreadLocal使用示例

示例一：

package com.shepherd.example.juc;

/**
 * @author fjzheng
 * @version 1.0
 * @date 2022/4/24 17:52
 */
public class ThreadLocalDemo {
   
   

    private static ThreadLocal<Integer> countValue = new ThreadLocal<Integer>(){
   
   
        // 实现initialValue()
        public Integer initialValue() {
   
   
            return 0;
        }
    };

    public int nextSeq(){
   
   
        countValue.set(countValue.get()  + 1);
        return countValue.get();
    }

    public static void main(String[] args){
   
   
         ThreadLocalDemo demo = new ThreadLocalDemo();
        MyThread thread1 = new MyThread(demo);
        MyThread thread2 = new MyThread(demo);
        MyThread thread3 = new MyThread(demo);
        MyThread thread4 = new MyThread(demo);

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }

    private static class MyThread extends Thread{
   
   
        private ThreadLocalDemo demo;

        MyThread(ThreadLocalDemo demo){
   
   
            this.demo = demo;
        }

        @Override
        public void run() {
   
   
            for(int i = 0 ; i < 3 ; i++){
   
   
                System.out.println(Thread.currentThread().getName() + " countValue :" + demo.nextSeq());
            }
        }
    }
}

通过设置一个countValue变量，然后每个线程绑定该变量，同时进行值更新操作，测试证明各个线程互相不影响，示例结果返回如下：

Thread-0 seqCount :1
Thread-3 seqCount :1
Thread-2 seqCount :1
Thread-1 seqCount :1
Thread-2 seqCount :2
Thread-3 seqCount :2
Thread-0 seqCount :2
Thread-3 seqCount :3
Thread-2 seqCount :3
Thread-1 seqCount :2
Thread-0 seqCount :3
Thread-1 seqCount :3

Process finished with exit code 0

示例二：平时我们用的比较多使用threadlocal存储登录，方便一次请求调用上下文获取登录信息

@Component
public class AuthInterceptor implements HandlerInterceptor {
   
   
    private static final String AUTHORIZE_TOKEN = "authorization";
    public static ThreadLocal<LoginVO> localUser = new ThreadLocal<>();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
   
   
        //网关服务会把token放在header里面
        String token = request.getHeader(AUTHORIZE_TOKEN);
        //如果为空，则输出错误代码
        if (StringUtils.isBlank(token)) {
   
   
            //设置方法不允许被访问，405错误代码
            response.setStatus(HttpStatus.METHOD_NOT_ALLOWED.value());
            return false;
        }

        //解析令牌数据
        try {
   
   
            Claims claims = JwtUtil.parseJWT(token);
            LoginVO loginVO = JSONObject.parseObject(claims.getSubject(), LoginVO.class);
            localUser.set(loginVO);
        } catch (Exception e) {
   
   
            e.printStackTrace();
            //解析失败，响应401错误
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            return false;
        }
        return true;
    }
  }

3.ThreadLocal源码

ThreadLocal虽然解决了这个多线程变量的复杂问题，但是它的源码实现却是比较简单的。ThreadLocalMap是实现ThreadLocal的关键，我们先从它入手。

ThreadLocalMap

ThreadLocalMap其内部利用Entry来实现key-value的存储，如下：

static class Entry extends WeakReference<ThreadLocal<?>> {
   
   
     /** The value associated with this ThreadLocal. */
     Object value;

     Entry(ThreadLocal<?> k, Object v) {
   
   
         super(k);
         value = v;
     }
 }

从上面代码中可以看出Entry的key就是ThreadLocal，而value就是值。同时，Entry也继承WeakReference，所以说Entry所对应key（ThreadLocal实例）的引用为一个弱引用.

ThreadLocalMap的源码稍微多了点，我们就看两个最核心的方法getEntry()、set(ThreadLocal> key, Object value)方法。

set(ThreadLocal> key, Object value)

private void set(ThreadLocal<?> key, Object value) {
   
   

    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;

    // 根据 ThreadLocal 的散列值，查找对应元素在数组中的位置
    int i = key.threadLocalHashCode & (len-1);

    // 采用“线性探测法”，寻找合适位置
    for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
        e != null;
        e = tab[i = nextIndex(i, len)]) {
   
   

        ThreadLocal<?> k = e.get();

        // key 存在，直接覆盖
        if (k == key) {
   
   
            e.value = value;
            return;
        }

        // key == null，但是存在值（因为此处的e != null），说明之前的ThreadLocal对象已经被回收了
        if (k == null) {
   
   
            // 用新元素替换陈旧的元素
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    // ThreadLocal对应的key实例不存在也没有陈旧元素，new 一个
    tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value);

    int sz = ++size;

    // cleanSomeSlots 清楚陈旧的Entry（key == null）
    // 如果没有清理陈旧的 Entry 并且数组中的元素大于了阈值，则进行 rehash
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

get()

返回当前线程所对应的线程变量

public T get() {
   
   
    // 获取当前线程
    Thread t = Thread.currentThread();

    // 获取当前线程的成员变量 threadLocal
    ThreadLocalMap map = getMap(t);
    if (map != null) {
   
   
        // 从当前线程的ThreadLocalMap获取相对应的Entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
   
   
            @SuppressWarnings("unchecked")

            // 获取目标值
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

首先通过当前线程获取所对应的成员变量ThreadLocalMap，然后通过ThreadLocalMap获取当前ThreadLocal的Entry，最后通过所获取的Entry获取目标值result。

getMap()方法可以获取当前线程所对应的ThreadLocalMap，如下：

ThreadLocalMap getMap(Thread t) {
   
   
    return t.threadLocals;
}

set(T value)

设置当前线程的线程局部变量的值。

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

获取当前线程所对应的ThreadLocalMap，如果不为空，则调用ThreadLocalMap的set()方法，key就是当前ThreadLocal，如果不存在，则调用createMap()方法新建一个，如下：

void createMap(Thread t, T firstValue) {
   
   
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

4.ThreadLocal为什么会内存泄漏

前面提到每个Thread都有一个ThreadLocal.ThreadLocalMap的map，该map的key为ThreadLocal实例，它为一个弱引用，我们知道弱引用有利于GC回收。当ThreadLocal的key == null时，GC就会回收这部分空间，但是value却不一定能够被回收，因为他还与Current Thread存在一个强引用关系，如下

由于存在这个强引用关系，会导致value无法回收。如果这个线程对象不会销毁那么这个强引用关系则会一直存在，就会出现内存泄漏情况。所以说只要这个线程对象能够及时被GC回收，就不会出现内存泄漏。如果碰到线程池，那就更坑了。

那么要怎么避免这个问题呢？

在ThreadLocalMap中的setEntry()、getEntry()，如果遇到key == null的情况，会对value设置为null。当然我们也可以显示调用ThreadLocal的remove()方法进行处理。

下面再对ThreadLocal进行简单的总结：

1.ThreadLocal 不是用于解决共享变量的问题的，也不是为了协调线程同步而存在，而是为了方便每个线程处理自己的状态而引入的一个机制。这点至关重要。

2.每个Thread内部都有一个ThreadLocal.ThreadLocalMap类型的成员变量，该成员变量用来存储实际的ThreadLocal变量副本。

3.hreadLocal并不是为线程保存对象的副本，它仅仅只起到一个索引的作用。它的主要木得视为每一个线程隔离一个类的实例，这个实例的作用范围仅限于线程内部。