都2021年了连ThreadLocal都没听过

今天药忘吃喽~ 2022-11-13 11:27 154阅读 0赞

### 文章目录 ###

*  问题背景
 *  前言
 *  Thread ThreadLocal ThreadLocalMap 之间的关系
 *  什么是ThreadLocal
 *  初探ThreadLocal
 *   *  ThreadLocalMap
     *   *  Entry
         *  INITIAL\_CAPACITY
         *  Entry\[\] table
         *  size
         *  threshold
     *  HASH\_INCREMENT
     *  nextHashCode
     *  threadLocalHashCode
     *  SuppliedThreadLocal
     *  initialValue()
     *  withInitial()
 *  小试牛刀
 *  玩玩并发测试
 *  总结

# 问题背景 #

--------------------

> 场景：公司项目前端发请求到后端，后端用拦截器拦截请求，做一些处理，可以将前端发来的参数保存到ThreadLocal里面。后面在controller、service等地方都可以通过ThreadLocal获取传来的参数。今天来简单了解一下ThreadLocal。说实话，我是真的第一次接触到ThreadLocal

# 前言 #

--------------------

> 基于jdk1.8来研究。由于文章前面出现的某些知识可能在后面才会介绍到，后面出现的知识需要返回到前面联系起来，因此**建议阅读时联系上下文，常前后翻看才会更加容易阅读并理解**。

> 参考自：
> 
>  *  jdk1.8 源码
>  *  [Java面试题必备知识之ThreadLocal][Java_ThreadLocal]

# Thread ThreadLocal ThreadLocalMap 之间的关系 #

--------------------

> 先简单从下图了解三者之间的关系，对后面的阅读有帮助。

![6][]

# 什么是ThreadLocal #

--------------------

> 先去看看源码的介绍：  
> This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable. ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).  
> 译文：这个类提供线程局部变量。这些变量与普通变量的不同之处在于，每个访问这些变量的线程(通过其get或set方法)都有自己独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态字段，它们希望将状态与线程(例如，用户ID或事务ID)关联起来。

# 初探ThreadLocal #

--------------------

## ThreadLocalMap ##

> 源码介绍：
> 
> ThreadLocalMap is a customized hash map suitable only for maintaining thread local values. No operations are exported outside of the ThreadLocal class. The class is package private to allow declaration of fields in class Thread. To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys. However, since reference queues are not used, stale entries are guaranteed to be removed only when the table starts running out of space.
> 
> 译文：ThreadLocalMap是一个定制的散列映射，只适合维护线程本地值。在ThreadLocal类之外不导出任何操作。该类是包私有的，允许在类Thread中声明字段。为了帮助处理非常大且长期存在的用法，哈希表条目对键使用弱引用。但是，由于没有使用引用队列，所以只有当表开始用完空间时，陈旧的条目才会被删除。

### Entry ###

--------------------

> 源码介绍：
> 
> The entries in this hash map extend WeakReference, using its main ref field as the key (which is always a ThreadLocal object). Note that null keys (i.e. entry.get() == null) mean that the key is no longer referenced, so the entry can be expunged from table. Such entries are referred to as “stale entries” in the code that follows.
> 
> 译文：这个哈希映射中的条目扩展了WeakReference，使用它的主ref字段作为键(它总是一个ThreadLocal对象)。请注意，空键(即entry.get() == null)意味着键不再被引用，所以条目可以从表中删除。在下面的代码中，这样的条目被称为“陈旧条目”。

static class Entry extends WeakReference<ThreadLocal<?>> { 
        /** The value associated with this ThreadLocal. */
        Object value;
    
        Entry(ThreadLocal<?> k, Object v) { 
            super(k);
            value = v;
        }
    }

总结：ThreadLocalMap只提供给ThreadLocal使用，该Map是一个定制（采用线性探测法并非HashMap常用的链表）的散列映射。Map的key是ThreadLocal对象（该对象是被WeakReference包装的），object是与ThreadLocal的有关的值。

### INITIAL\_CAPACITY ###

--------------------

> 源码介绍：
> 
> The initial capacity – MUST be a power of two.
> 
> 译文：初始化容量必须是2的幂次方

private static final int INITIAL_CAPACITY = 16;

为什么是2的幂次方？原理与HashMap大同小异。详情可见我的另一篇博客：[HashMap常见问题][HashMap]

### Entry\[\] table ###

--------------------

> 源码介绍：
> 
> The table, resized as necessary. table.length MUST always be a power of two.
> 
> 译文：表，根据需要调整大小。表格长度必须是2的幂。

private Entry[] table;

这个table就是真正存储key、value的地方。前面也有介绍到Entry类。

### size ###

--------------------

> 源码介绍：
> 
> The number of entries in the table.
> 
> 译文：表中键值对的个数

private int size = 0;

记录表中键值对的个数。

### threshold ###

--------------------

> 源码介绍：
> 
> The next size value at which to resize.
> 
> 译文：阈值，键值对的个数超过阈值时，table将会扩容

private int threshold;

table中键值对的阈值。

## HASH\_INCREMENT ##

> 源码介绍如下：
> 
> The difference between successively generated hash codes - turns implicit sequential thread-local IDs into near-optimally spread multiplicative hash values for power-of-two-sized tables.
> 
> 译文：连续生成的哈希码之间的区别——将隐式的顺序线程本地id转换为用于两倍大小表的近乎最优扩展的乘法哈希值。

private static final int HASH_INCREMENT = 0x61c88647;

网上称该属性为魔数，用于解决插入值到一个数组中造成冲突，与线性探测法有关。普通的HashMap是用链表解决冲突的，但是ThreadLocalMap使用线性探测法来处理冲突的，HASH\_INCREMENT就是每次增加的步长。该值是经过斐波那契数列研究才采用的，可以将值均匀地存入数组中，提高性能。

## nextHashCode ##

> 源码介绍：
> 
> The next hash code to be given out. Updated atomically. Starts at zero.
> 
> 译文：要给出的下一个哈希码。自动更新。从0开始。

private static AtomicInteger nextHashCode = new AtomicInteger();

使用原子类整形型生成下一个哈希码。

## threadLocalHashCode ##

> 源码介绍：
> 
> ThreadLocals rely on per-thread linear-probe hash maps attached to each thread (Thread.threadLocals and inheritableThreadLocals). The ThreadLocal objects act as keys, searched via threadLocalHashCode. This is a custom hash code (useful only within ThreadLocalMaps) that eliminates collisions in the common case where consecutively constructed ThreadLocals are used by the same threads, while remaining well-behaved in less common cases.
> 
> 译文：threadlocal依赖于每个线程的线性探测散列映射(Thread.threadlocal和InheritableThreadlocals)。ThreadLocal对象充当键，通过threadLocalHashCode进行搜索。这是一个自定义散列代码(仅在ThreadLocalMaps中有用)，它在相同线程使用连续构造的threadlocal的常见情况下消除了冲突，而在不太常见的情况下保持良好的行为。

private final int threadLocalHashCode = nextHashCode();
    
    private static int nextHashCode() { 
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

用于标识一个ThreadLocal，通过在数组上搜索threadLocalHashCode可以快速获取到值

## SuppliedThreadLocal ##

> 源码介绍：
> 
> An extension of ThreadLocal that obtains its initial value from the specified Supplier.
> 
> 译文：ThreadLocal的扩展，从指定的供应商获得初始值。

static final class SuppliedThreadLocal<T> extends ThreadLocal<T> { 
    
        private final Supplier<? extends T> supplier;
    
        SuppliedThreadLocal(Supplier<? extends T> supplier) { 
            this.supplier = Objects.requireNonNull(supplier);
        }
    
        @Override
        protected T initialValue() { 
            return supplier.get();
        }
    }

貌似是用来初始化ThreadLocal，暂时没看懂。

## initialValue() ##

> 源码介绍：
> 
> Returns the current thread’s “initial value” for this thread-local variable. This method will be invoked the first time a thread accesses the variable with the get method, unless the thread previously invoked the set method, in which case the initialValue method will not be invoked for the thread. Normally, this method is invoked at most once per thread, but it may be invoked again in case of subsequent invocations of remove followed by get.  
> This implementation simply returns null; if the programmer desires thread-local variables to have an initial value other than null, ThreadLocal must be subclassed, and this method overridden. Typically, an anonymous inner class will be used.  
> Returns:  
> the initial value for this thread-local
> 
> 译文：返回当前线程的这个线程局部变量的“初始值”。该方法将在线程第一次使用get方法访问变量时被调用，除非线程之前调用了set方法，在这种情况下，将不会为线程调用initialValue方法。通常，每个线程最多调用一次此方法，但在后续调用remove和get的情况下，可以再次调用该方法。
> 
> 这个实现只是返回null;如果程序员希望线程局部变量的初始值不是null，则必须子类化ThreadLocal，并覆盖该方法。通常，将使用匿名内部类。
> 
> 返回:
> 
> 这个线程局部的初始值

protected T initialValue() { 
    	return null;
    }

线程第一次用get()访问变量时，会调用该方法，除非之前用了set()。

## withInitial() ##

> 源码介绍：
> 
> Creates a thread local variable. The initial value of the variable is determined by invoking the get method on the Supplier.  
> Params:supplier – the supplier to be used to determine the initial value  
> Type parameters:the type of the thread local’s value  
> Returns:a new thread local variable  
> Throws:NullPointerException - if the specified supplier is null  
> Since:1.8
> 
> 译文：创建线程局部变量。变量的初始值是通过调用供应商的get方法来确定的。
> 
> 参数: 供应商——用于确定初始值的供应商
> 
> 类型参数:-线程本地值的类型
> 
> 返回:一个新的线程局部变量
> 
> 抛出:NullPointerException——如果指定的供应商为空
> 
> 自:1.8

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) { 
    	return new SuppliedThreadLocal<>(supplier);
    }

返回一个新的线程局部变量

# 小试牛刀 #

--------------------

> 了解完了ThreadLocal的大概，就来做点小实验。实现的场景是前端发送请求，请求头里面有username、userId，后端拦截请求，把username、userId保存到ThreadLocal里面。

> Controller：

@RestController
    public class TestController { 
    
        @Autowired
        private ThreadLocalTest threadLocalTest;
    
        @GetMapping("/test")
        public void test() { 
            threadLocalTest.test();
        }
    }

> Service：

public interface ThreadLocalTest { 
        void test();
    }

> ServiceImpl：

@Service
    @Slf4j
    public class ThreadLocalTestImp implements ThreadLocalTest { 
    
        @Override
        public void test() { 
            log.info("username: {}", GlobalParamInfo.getUsername());
            log.info("userId: {}", GlobalParamInfo.getUserId());
        }
    }

> ThreadLocal：定义ThreadLocal

public class GlobalParamInfo { 
    
        private static final String USERNAME = "USERNAME";
        private static final String USERID = "USERID";
        private static final String ENCODE = "UTF-8";
        private static final ThreadLocal<Map<String, Object>> GLOBALPARAM = ThreadLocal.withInitial(HashMap::new);
    
        private GlobalParamInfo() { 
    
        }
    
        public static String getUsername() { 
            Object value = GLOBALPARAM.get().get(USERNAME);
            if (Objects.nonNull(value)) { 
                try { 
                    return URLDecoder.decode(value.toString(), ENCODE);
                } catch (UnsupportedEncodingException e) { 
                    return null;
                }
            }else { 
                return null;
            }
        }
    
        public static Long getUserId() { 
            Object value = GLOBALPARAM.get().get(USERID);
            return Objects.isNull(value) ? null : new SimpleTypeConverter().convertIfNecessary(value, Long.class);
        }
    
        public static <T> T get(String key, Class<T> clazz) { 
            Object value = GLOBALPARAM.get().get(key);
            return Objects.isNull(value) ? null : new SimpleTypeConverter().convertIfNecessary(value, clazz);
        }
    
        public static void put(String key, Object value) { 
            GLOBALPARAM.get().put(key, value);
        }
    
        public static void clear() { 
            GLOBALPARAM.remove();
        }
    }

> Inteceptor：定义拦截器

public class ParamInterceptor implements HandlerInterceptor { 
    
        private static final String USERNAME = "USERNAME";
        private static final String USERID = "USERID";
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
            String username = request.getHeader("username");
            String userId = request.getHeader("userId");
            GlobalParamInfo.put(USERNAME, username);
            GlobalParamInfo.put(USERID, userId);
    
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { 
    
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { 
            GlobalParamInfo.clear();
        }
    }

> config：注册拦截器

@Configuration
    public class WebMvcConfig implements WebMvcConfigurer { 
    
        @Bean
        public ParamInterceptor paramInterceptor() { 
            return new ParamInterceptor();
        }
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) { 
            registry.addInterceptor(paramInterceptor())
                    .addPathPatterns("/**");
        }
    }

> 测试：

![6][6 1]

> 效果：

![7][]

# 玩玩并发测试 #

> 上面发起单个请求没问题，那么试试并发请求后，是否还能正常获取到前端传来的值。笔者使用JMeter做并发测试。操作如下：

> 新建线程组：右击测试计划-添加-线程（用户）-线程组

![8][]

如上，新建一个线程组，线程数设置99。

> 新建HTTP请求：右击线程组-添加-取样器-HTTP请求

![9][]

填写相关的请求信息

> 新建用户参数：右击HTTP请求-添加-前置处理器-用户参数，用作动态生成请求头的数据

![10][]

> 新建HTTP信息头管理器：右击HTTP请求-添加-配置原件-HTTP信息头管理器

![11][]

> 新建察看结果树：右击HTTP请求-添加-监听器-查看结果树

![12][]

> 启动线程组：

![13][]

> 结果：等程序运行完，就会看到后台打印了很多信息，这些都是动态发送到后端的。

![14][]

# 总结 #

--------------------

本文主要是ThreadLocal零基础入门，以真实项目中的常见传参场景初步了解ThreadLocal。

[Java_ThreadLocal]: https://blog.csdn.net/duqi_2009/article/details/96765693
[6]: /images/20221022/afa6c0b82c5246219b5a044f9d85b513.png
[HashMap]: https://blog.csdn.net/qq_40634846/article/details/106017742
[6 1]: https://img-blog.csdnimg.cn/img_convert/1d35fd9784bb4c18d0ad6ddd347cd7c4.png
[7]: https://img-blog.csdnimg.cn/img_convert/67f95c5a809a80731d401e0d049a0538.png
[8]: https://img-blog.csdnimg.cn/img_convert/673d4c4d6829b44762bdf8f91049370a.png
[9]: https://img-blog.csdnimg.cn/img_convert/a925d26ad98257807e0157075d2504c0.png
[10]: https://img-blog.csdnimg.cn/img_convert/de68ad303701e3aa00a4cc4ee2da5994.png
[11]: https://img-blog.csdnimg.cn/img_convert/a1190cba07f8239c4d383be3a57ab512.png
[12]: https://img-blog.csdnimg.cn/img_convert/9ac35c484ea271fe1585eee6c9e1f291.png
[13]: https://img-blog.csdnimg.cn/img_convert/2b7a50dbfd977d43ac94fd57932a4f36.png
[14]: https://img-blog.csdnimg.cn/img_convert/f9532157472aa14819d6ec57bc5cca0a.png