ThreadLocal类详解

骑猪看日落 2022-09-02 12:53 218阅读 0赞

### 文章目录 ###

*   *  ThreadLocal类详解
     *   *  一、简介
         *  二、数据结构
         *  三、ThreadLocalMap的Hash算法
         *  四、ThreadLocal原理详解
         *  五、ThreadLocalMap过期key的清理流程
         *  六、ThreadLocal的扩容机制
         *  七、内存泄漏的避免方法

## ThreadLocal类详解 ##

### 一、简介 ###

从名字我们就可以看到ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于**当前**线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

**作用场景：**

**1、在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。**

**2、线程间数据隔离**

**3、进行事务操作，用于存储线程事务信息。**

**4、数据库连接，Session会话管理。**

### 二、数据结构 ###

![img][]

Thread类的有一个类型**ThreadLocal.ThreadLocalMap**的实例变量threadLocals,也就是说意味着每一个线程都有自己的**ThreadLocalMap**。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70_pic_center]

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70_pic_center 1]

`ThreadLocalMap`有点类似`HashMap`的结构，只是`HashMap`是由**数组+链表**实现的，而`ThreadLocalMap`中并没有**链表**结构。

我们还要注意`Entry`， 它的`key`是`ThreadLocal<?> k` ，继承自`WeakReference`， 也就是我们常说的弱引用类型。

### 三、ThreadLocalMap的Hash算法 ###

我们需要先记住一行代码，后面仍会涉及：

int i = key.threadLocalHashCode & (len-1);

可以看出它的hash算法是很简单的，和HashMap的基本是一致的，但这个**threadLocalHashCode**是怎么得到的呢？

private final int threadLocalHashCode = nextHashCode();
    
    /**
     * The next hash code to be given out. Updated atomically. Starts at
     * zero.
     */
    private static AtomicInteger nextHashCode =
        new AtomicInteger();
    
    /**
     * 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.
     */
    private static final int HASH_INCREMENT = 0x61c88647;
    
    /**
     * Returns the next hash code.
     */
    private static int nextHashCode() {
        
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

从这里我们不难看出，ThreadLocal类声明了一个**AtomicInteger**的静态变量，静态常量**HASH\_INCREMENT** 和一个**nextHashCode**的静态方法，每一个ThreadLocal的**threadLocalHashCode**就是通过一个**Volatile+CAS**的方式，每一次去加上一个0x61c88647的值，从而得到每个ThreadLocal实例的Hash值。

**注意：采用0x61c88647**这个值的原因是因为该值是**斐波那契数** 也叫 **黄金分割数**，hash值以此值为增量的话，可以是的hash分布非常均匀，从而最大限度地去避免hash冲突;

### 四、ThreadLocal原理详解 ###

**ThreadLocal类的set(T value)方法**

（1）获取当前线程；

（2）获取当前线程的ThreadLocalMap的实例变量

（3）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);
    }
    //getMap方法
    ThreadLocalMap getMap(Thread t) {
        
          //thred中维护了一个ThreadLocalMap
          return t.threadLocals;
     }
    
    void createMap(Thread t, T firstValue) {
        
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

**ThreadLocalMap.set（ThreadLocal<?> key, Object value）方法**

（1）如上可以看到**ThreadLocalMap**的Entry中可以存储多个ThreadLocal，Entry中的每一个key即代表一个ThreadLocal，主要就是用来适应我们在一个线程中去声明多个ThreadLocal的情况；

//在某一线程声明了ABC三种类型的ThreadLocal
    ThreadLocal<A> sThreadLocalA = new ThreadLocal<A>();
    ThreadLocal<B> sThreadLocalB = new ThreadLocal<B>();
    ThreadLocal<C> sThreadLocalC = new ThreadLocal<C>();

（2）通过hash算法去获得要注入值的key在table中的下标位置；

private void set(ThreadLocal<?> key, Object value) {
        
        Entry[] tab = table;
        int len = tab.length;
        int i = key.threadLocalHashCode & (len-1);
    
        for (Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
        
            ThreadLocal<?> k = e.get();
    
            if (k == key) {
        
                e.value = value;
                return;
            }
    
            if (k == null) {
        
                replaceStaleEntry(key, value, i);
                return;
            }
        }
    
        tab[i] = new Entry(key, value);
        int sz = ++size;
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }

（3）接下来的真正的Entry中插入数据的部分就比较复杂了，设计到了Hash冲突等情况的解决办法；具体如下：**思想：** 由于**ThreadLocalMap**只有数组，并没有使用HashMap那样的链表通过拉链法来处理Hash冲突，所以只能使用线性探测法，每当发生Hash冲突时，则往后去n个位置去查看空闲位置插入；

**实现方法：**

*  通过hash计算后的槽位对应的`Entry`数据为空：这里直接将数据放到该槽位即可。
 *  槽位数据不为空，`key`值与当前`ThreadLocal`通过`hash`计算获取的`key`值一致：这里直接更新该槽位的数据。
 *  槽位数据不为空，往后遍历过程中，在找到`Entry`为`null`的槽位之前，没有遇到`key`过期的`Entry`：遍历散列数组，线性往后查找，如果找到`Entry`为`null`的槽位，则将数据放入该槽位中，或者往后遍历过程中，遇到了**key值相等**的数据，直接更新即可。
 *  槽位数据不为空，往后遍历过程中，在找到`Entry`为`null`的槽位之前，遇到`key`过期的`Entry`,表明此数据`key`值已经被垃圾回收掉了，此时就会执行`replaceStaleEntry()`方法，该方法含义是**替换过期数据的逻辑**，以**index=7**位起点开始遍历，进行探测式数据清理工作.

**ThreadLocal的get()方法**

（1）获取当前线程；

（2）获取当前线程的ThreadLocalMap；

（3）如果ThreadLocalMap非空，则将其对应的值返回；

（4）否则，初始化其对应的ThreadLocalMap，放入ThreadLocal

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();
    }

**第一种情况：** 通过查找`key`值计算出散列表中`slot`位置，然后该`slot`位置中的`Entry.key`和查找的`key`一致，则直接返回：

**第二种情况：** `slot`位置中的`Entry.key`和要查找的`key`不一致：

我们以`get(ThreadLocal1)`为例，通过`hash`计算后，正确的`slot`位置应该是4，而`index=4`的槽位已经有了数据，且`key`值不等于`ThreadLocal1`，所以需要继续往后迭代查找。

迭代到`index=5`的数据时，此时`Entry.key=null`，触发一次探测式数据回收操作，执行`expungeStaleEntry()`方法，执行完后，`index 5`的数据都会被回收，而`index 6,7`的数据都会前移，此时继续往后迭代，到`index = 6`的时候即找到了`key`值相等的`Entry`数据，

private Entry getEntry(ThreadLocal<?> key) {
        
        int i = key.threadLocalHashCode & (table.length - 1);
        Entry e = table[i];
        if (e != null && e.get() == key)
            return e;
        else
            return getEntryAfterMiss(key, i, e);
    }
    
    private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
        
        Entry[] tab = table;
        int len = tab.length;
    
        while (e != null) {
        
            ThreadLocal<?> k = e.get();
            if (k == key)
                return e;
            if (k == null)
                expungeStaleEntry(i);
            else
                i = nextIndex(i, len);
            e = tab[i];
        }
        return null;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70_pic_center 2]

### 五、ThreadLocalMap过期key的清理流程 ###

**探测式清理**：遍历散列数组，从开始位置向后探测清理过期数据，将过期数据的`Entry`设置为`null`，沿途中碰到未过期的数据则将此数据`rehash`后重新在`table`数组中定位，如果定位的位置已经有了数据，则会将未过期的数据放到最靠近此位置的`Entry=null`的桶中，使`rehash`后的`Entry`数据距离正确的桶的位置更近一些；

启发式清理：试探的扫描一些单元格，寻找过期元素，也就是被垃圾回收的元素。当添加新元素或删除另一个过时元素时，将调用此函数。它执行对数扫描次数，作为不扫描（快速但保留垃圾）和与元素数量成比例的扫描次数之间的平衡，这将找到所有垃圾，但会导致一些插入花费O（n）时间；

![img][img 1]

### 六、ThreadLocal的扩容机制 ###

扩容后的`tab`的大小为`oldLen * 2`，然后遍历老的散列表，重新计算`hash`位置，然后放到新的`tab`数组中，如果出现`hash`冲突则往后寻找最近的`entry`为`null`的槽位，遍历完成之后，`oldTab`中所有的`entry`数据都已经放入到新的`tab`中了。重新计算`tab`下次扩容的**阈值**

### 七、内存泄漏的避免方法 ###

*  每次使用完ThreadLocal都调用它的remove方法清楚数据
 *  将ThreadLocal变量定义为private static，这样就一直存在ThreadLocal的强引用，也就能保证在任何时候都能通过ThreadLocal的弱引用访问到Entry的value值，继续清除。

**参考链接：**

https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/multi-thread/%E4%B8%87%E5%AD%97%E8%AF%A6%E8%A7%A3ThreadLocal%E5%85%B3%E9%94%AE%E5%AD%97.md

https://www.cnblogs.com/xiaofuge/p/13722506.html

[img]: /images/20220829/ad51425a8c324ca2ad9c24dcd70549c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/12df984a4d5445b49e8ff6c9b0b29236.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/108c43b8099f4f798956d010bdd43c77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/a4613bc462cc4e5799954a310ca9cb80.png
[img 1]: /images/20220829/9dcd6bd77d564fbb9acf88d8a36866df.png