我是陈皮，一个在互联网 Coding 的 ITer，微信搜索「陈皮的 JavaLib」第一时间阅读最新文章，回复【资料】，即可获得我精心整理的技术资料，电子书籍，一线大厂面试资料和优秀简历模板。
ThreadLocal 简介
Threadlocal 类提供了线程局部变量功能。意思可以在指定线程内部存储数据，并且哪个线程存储的数据只能线程它自己有权限取得。
底层原理其实是在线程内部维护一个 Map 变量，然后 Threadlocal 对象作为 key，要存储的数据作为 value。而 Threadlocal 类作为一个设置和访问这个线程局部变量的入口。
Threadlocal 对象一般定义为私有静态的，而且通过它的 get 和 set 方法设置和获取线程局部变量。
private static final ThreadLocal<UserContext> THREAD_LOCAL = new ThreadLocal<>();
复制代码
如何使用 ThreadLocal
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<>();
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 */@Datapublic 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 */@Componentpublic 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 */@Servicepublic class UserService {
public void chenPiDeJavaLib() { UserContext userContext = UserContextHolder.getUserContext(); }}
复制代码
评论