阅读 570

我是如何用 ThreadLocal 虐面试官的?

这是我参与更文挑战的第15天,活动详情查看: 更文挑战

我是陈皮,一个在互联网 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 源码分析

image-20210628002337639.png

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();
    }
}
复制代码
文章分类
后端
文章标签