ThreadLocal类详解

ThreadLocal类详解

一、简介

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

作用场景：

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

2、线程间数据隔离

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

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

二、数据结构

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

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

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

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

五、ThreadLocalMap过期key的清理流程

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

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

六、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