我是如何用 ThreadLocal 虐面试官的？丨【奔跑吧！JAVA】

华为云博客 技术博客 14413 52

我是陈皮，一个在互联网 Coding 的 ITer，微信搜索「陈皮的JavaLib」第一时间阅读最新文章，回复【资料】，即可获得我精心整理的技术资料，电子书籍，一线大厂面试资料和优秀简历模板。


ThreadLocal 简介

Threadlocal 类提供了线程局部变量功能。意思可以在指定线程内部存储数据，并且哪个线程存储的数据只能线程它自己有权限取得。

底层原理其实是在线程内部维护一个 Map 变量，然后 Threadlocal 对象作为 key，要存储的数据作为 value。而 Threadlocal 类作为一个设置和访问这个线程局部变量的入口。

Threadlocal 对象一般定义为私有静态的，而且通过它的 get 和 set 方法设置和获取线程局部变量。

private static final ThreadLocal<UserContext> THREAD_LOCAL = new ThreadLocal<>();

如何使用 ThreadLocal

ThreadLocal 使用方法很简单，它提供了三个公开的方法供外部调用。

  • void set(T value)：设置线程局部变量
  • T get()：获取线程局部变量
  • void remove()：删除线程局部变量
package com.chenpi;

/**
 * @Description
 * @Author 陈皮
 * @Date 2021/6/27
 * @Version 1.0
 */
public class ThreadLocalTest {

    private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();

    public static void main(String[] args) {
        // 设置线程局部变量
        THREAD_LOCAL.set("我是陈皮，个人公众号【陈皮的JavaLib】");
        // 使用线程局部变量
        peelChenpi();
        // 删除线程局部变量
        THREAD_LOCAL.remove();
        // 使用线程局部变量
        peelChenpi();
    }

    public static void peelChenpi() {
        System.out.println(THREAD_LOCAL.get());
    }
}

// 输出结果
我是陈皮，个人公众号【陈皮的JavaLib】
null

ThreadLocal 源码分析

ThreadLocal 底层原理是在线程内部维护一个 Map 变量，然后 Threadlocal 对象作为 key，要存储的数据作为 value。而 Threadlocal 类作为一个设置和访问这个线程局部变量的入口。

Thread 类中定义了一个 ThreadLocalMap 类型的变量 threadLocals，每个线程都有自己专属的 threadLocals 变量，ThreadLocalMap 类是由 ThreadLocal 维护的一个静态内部类。

ThreadLocal.ThreadLocalMap threadLocals = null;

Thread 的 threadLocals 变量是默认访问权限的，只能被同个包下的类访问，所以我们是不能直接使用 Thread 的 threadLocals 变量的，这也就是为什么能控制不同线程只能获取自己的数据，达到了线程隔离。Threadlocal 类是访问它的入口。

Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);

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

ThreadLocal 类中的静态内部类 ThreadLocalMap 部分源码如下，底层是维护的了一个 Entry 类型数组 table。

static class ThreadLocalMap {

        // Map中的Entry对象，弱引用类型，key是ThreadLocal对象，value是线程局部变量
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
    
        // 初始化容量16，必须是2的幂次方
        private static final int INITIAL_CAPACITY = 16;
    
        // 存储数据的数组，可扩容，长度必须是2的幂次方
        private Entry[] table;

        // table数组的大小
        private int size = 0;

        // table数组的阈值，达到则扩容
        private int threshold; // Default to 0
        
}

为什么 ThreadLocalMap 内部存储机构是维护一个数组呢？因为一个线程是可以通过多个不同的 ThreadLocal 对象来设置多个线程局部变量的，这些局部变量都是存储在自己线程的同一个 ThreadLocalMap 对象中。通过不同的 ThreadLocal 对象可以取得当前线程的不同局部变量值。

package com.chenpi;

/**
 * @Description
 * @Author 陈皮
 * @Date 2021/6/27
 * @Version 1.0
 */
public class ThreadLocalTest {

    private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();

    private static final ThreadLocal<String> THREAD_LOCAL01 = new ThreadLocal<>();

    public static void main(String[] args) {
        THREAD_LOCAL.set("我是陈皮");
        System.out.println(THREAD_LOCAL.get());

        THREAD_LOCAL01.set("陈皮是我");
        System.out.println(THREAD_LOCAL01.get());
    }
}

那同一个线程的 ThreadLocalMap 对象的数组 table，当前线程的不同 ThreadLocal 是如何确定数组下标，如果数组下标冲突又是怎么解决的呢？其实它不同于 HashMap 底层数组+链表+红黑树的存储结构，它只有 Entry 数组。

ThreadLocal 有个静态的初始哈希值 nextHashCode，然后每新建一个 ThreadLocal 对象都会在此哈希值的基础上自增一次，自增量为0x61c88647。

// 每 new 一个 ThreadLocal 对象都会自增一次哈希值
private final int threadLocalHashCode = nextHashCode();

// 初始哈希值，静态变量
private static AtomicInteger nextHashCode =
    new AtomicInteger();

// 自增量
private static final int HASH_INCREMENT = 0x61c88647;

// 自增一次
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

然后计算 table 数组下标是通过以下算法确定的，如果下标冲突，则下标会往后挪一位继续判断，直到不冲突为止。

// 首次创建 ThreadLocalMap 对象时，第一个元素的下标计算
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 后续元素的下标计算
int i = key.threadLocalHashCode & (len-1);
// 下标冲突时计算下一个下标的方法
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

我们看 ThreadLocal 类的 set 方法源码，它是设置线程局部变量的入口方法，实现原理也很简单。

  • 首先获取当前线程的 ThreadLocalMap 变量
  • 如果 ThreadLocalMap 变量存在，则将 ThreadLocal 对象和 T 数据以键值对的形式存储到 ThreadLocalMap 变量中
  • 如果 ThreadLocalMap 变量不存在，则新建 ThreadLocalMap 变量并绑定到当前线程中，再将 ThreadLocal 对象和 T 数据以键值对的形式存储到 ThreadLocalMap 变量中
// 设置线程局部变量
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

ThreadLocal 类的 get 方法，它是访问线程局部变量的入口方法，实现原理也很简单。

  • 首先获取当前线程的 ThreadLocalMap 变量
  • 如果 ThreadLocalMap 变量存在，则将 ThreadLocal 对象作为 key，在 ThreadLocalMap 变量中查找对应的线程局部变量
  • 如果 ThreadLocalMap 变量不存在，则新建 ThreadLocalMap 变量并绑定到当前线程中，再将 ThreadLocal 对象和 null 以键值对的形式存储到 ThreadLocalMap 变量中
// 访问线程局部变量
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();
}

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

protected T initialValue() {
    return null;
}

ThreadLocal 类的 remove 方法，直接清除线程中 ThreadLocalMap 对象中以当前 ThreadLocal 对象为 key 的 Entry对象。

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

你是否发现，ThreadLocal 类中的所有方法都是没有加锁的，因为 ThreadLocal 最终操作的都是对当前线程的 ThreadLocalMap 对象进行操作，既然线程处理自己的局部变量，就肯定不会有线程安全问题。

注意，同一个 ThreadLocal 变量在父线程中被设置值后，在子线程中是获取这个值的。即不具备继承性。具有继承性的是 InheritableThreadLocal 类，下期文章再讲解这个。


ThreadLocal 应用

ThreadLocal 具有线程隔离，线程安全的效果，如果数据是以线程为作用域并且不同线程具有不同的数据的时候，采用 ThreadLocal 是个不错的选择。

例如对于要用户登录的服务，对于每一个请求，我们可能需要校验用户是否登录，以及在登录后，后续的请求中会使用到用户信息，那我们就可以将登录校验过的用户信息放入线程局部变量中。

首先定义一个用户信息类，存放用户登录校验过的用户信息。

package com.chenpi;

import lombok.Data;

/**
 * @Description
 * @Author 陈皮
 * @Date 2021/6/27
 * @Version 1.0
 */
@Data
public class UserContext {

    private String userId;
    private String userName;
}

定义一个持有用户信息的管理工具类，主要用户管理当前线程的用户信息。

package com.chenpi;

/**
 * @Description
 * @Author 陈皮
 * @Date 2021/6/27
 * @Version 1.0
 */
public class UserContextHolder {

    private static final ThreadLocal<UserContext> THREAD_LOCAL = new ThreadLocal<>();

    private UserContextHolder() {}

    public static void setUserContext(UserContext userContext) {
        THREAD_LOCAL.set(userContext);
    }

    public static UserContext getUserContext() {
        return THREAD_LOCAL.get();
    }

    public static void removeUserContext() {
        THREAD_LOCAL.remove();
    }
}

对需要用户权限的接口进行拦截，然后将用户信息存储到当前线程内部。注意，当请求完成后，需要将用户信息进行清除，避免内存泄露问题。

package com.chenpi;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

/**
 * @Description 用户权限验证拦截
 * @Author 陈皮
 * @Date 2021/6/27
 * @Version 1.0
 */
@Component
public class UserPermissionInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
            Object handler) {

        if (handler instanceof HandlerMethod) {

            HandlerMethod handlerMethod = (HandlerMethod) handler;

            // 获取用户权限校验注解
            UserAuthenticate userAuthenticate =
                    handlerMethod.getMethod().getAnnotation(UserAuthenticate.class);
            if (null == userAuthenticate) {
                userAuthenticate = handlerMethod.getMethod().getDeclaringClass()
                        .getAnnotation(UserAuthenticate.class);
            }
            if (userAuthenticate != null && userAuthenticate.permission()) {
                // 验证用户信息
                UserContext userContext = userContextManager.getUserContext(request);
                // 将用户信息存储到线程内部
                UserContextHolder.setUserContext(userContext);
            }
        }
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
            Object handler, @Nullable Exception ex) {
        // 请求完后，清除当前线程的用户信息，避免内存泄露和用户信息混乱
        UserContextHolder.removeUserContext();
    }
}

至此，我们就能在当前请求的同一线程内，不用通过方法参数显示传递用户信息，可以通过工具类随时随地获取到当前用户信息了。

而且你会发现，如果方法调用链 A - B - C，AB 不需要用户信息，C 需要用户信息，那你需要层层通过方法参数传递用户信息。而使用 ThreadLocal 后，不用通过方法参数层层传递用户信息，避免了依赖污染，代码也更加简洁。

package com.chenpi;

import org.springframework.stereotype.Service;

/**
 * @Description
 * @Author 陈皮
 * @Date 2021/6/27
 * @Version 1.0
 */
@Service
public class UserService {

    public void chenPiDeJavaLib() {
        UserContext userContext = UserContextHolder.getUserContext();
    }
}

【奔跑吧！JAVA】有奖征文火热进行中：https://bbs.huaweicloud.com/blogs/265241

（完）