第二十六章 java并发常见知识内容（ThreadLocal 详解）

带着疑问看

ThreadLocal的 key 是弱引用，那么在 ThreadLocal.get()的时候，发生GC之后，key 是否为null？
ThreadLocal中ThreadLocalMap的数据结构？
ThreadLocalMap的Hash 算法？
ThreadLocalMap中Hash 冲突如何解决？
ThreadLocalMap的扩容机制？
ThreadLocalMap中过期 key 的清理机制？
探测式清理和启发式清理流程？
ThreadLocalMap.set()方法实现原理？
ThreadLocalMap.get()方法实现原理？
项目中ThreadLocal使用情况？

ThreadLocal

public class ThreadLocalTest {private List<String> messages = Lists.newArrayList();public static final ThreadLocal<ThreadLocalTest> holder = ThreadLocal.withInitial(ThreadLocalTest::new);public static void add(String message) {holder.get().messages.add(message);}public static List<String> clear() {List<String> messages = holder.get().messages;holder.remove();System.out.println("size: " + holder.get().messages.size());return messages;}public static void main(String[] args) {ThreadLocalTest.add("TSES");System.out.println(holder.get().messages);ThreadLocalTest.clear();}
}
打印如下：
[SES]
size: 0

ThreadLocal对象可以提供线程局部变量，每个线程Thread拥有一份自己的副本变量，多个线程互不干扰。

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， 也就是我们常说的弱引用类型。

GC 之后 key 是否为 null？

补充：Java的四种引用类型
强引用： new 出来的对象就是强引用类型，只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足的时候
软引用：使用 SoftReference 修饰的对象被称为软引用，软引用指向的对象在内存要溢出的时候被回收
弱引用：使用 WeakReference 修饰的对象被称为弱引用，只要发生垃圾回收，若这个对象只被弱引用指向，那么就会被回收
虚引用：虚引用是最弱的引用，在 Java 中使用 PhantomReference 进行定义。虚引用中唯一的作用就是用队列接收对象即将死亡的通知

如果强引用不存在的话，那么 key 就会被回收，也就是会出现 value 没被回收，key 被回收，导致 value 永远存在，出现内存泄漏。

ThreadLocal.set()方法源码如下：（主要是判断ThreadLocalMap是否存在，然后使用ThreadLocal中的set方法进行数据处理。）

public void set(T value) {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value);
}void createMap(Thread t, T firstValue) {t.threadLocals = new ThreadLocalMap(this, firstValue);
}

ThreadLocalMap Hash 算法

ThreadLocalMap当然也要实现自己的hash算法来解决散列表数组冲突问题。

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

ThreadLocalMap中hash算法很简单，这里i就是当前 key 在散列表中对应的数组下标位置。
threadLocalHashCode值的计算，ThreadLocal中有一个属性为HASH_INCREMENT = 0x61c88647

public class ThreadLocal<T> {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);}static class ThreadLocalMap {ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {table = new Entry[INITIAL_CAPACITY];int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);table[i] = new Entry(firstKey, firstValue);size = 1;setThreshold(INITIAL_CAPACITY);}}
}

每当创建一个ThreadLocal对象，这个ThreadLocal.nextHashCode 这个值就会增长 0x61c88647 。这个值很特殊，它是斐波那契数 也叫 黄金分割数。hash增量为 这个数字，带来的好处就是 hash 分布非常均匀。

ThreadLocalMap Hash 冲突

虽然ThreadLocalMap中使用了黄金分割数来作为hash计算因子，大大减少了Hash冲突的概率，但是仍然会存在冲突。HashMap中解决冲突的方法是在数组上构造一个链表结构，冲突的数据挂载到链表上，如果链表长度超过一定数量则会转化成红黑树。而 ThreadLocalMap 中并没有链表结构，所以这里不能使用 HashMap 解决冲突的方式了。

ThreadLocalMap.set()方法

往ThreadLocalMap中set数据（新增或者更新数据）分为好几种情况：

1. 第一种情况： 通过hash计算后的槽位对应的Entry数据为空：
   直接将数据放到该槽位
2. 第二种情况： 槽位数据不为空，key值与当前ThreadLocal通过hash计算获取的key值一致：
   直接更新该槽位的数据
3. 第三种情况： 槽位数据不为空，往后遍历过程中，在找到Entry为null的槽位之前，没有遇到key过期的Entry：
   遍历散列数组，线性往后查找，如果找到Entry为null的槽位，则将数据放入该槽位中，或者往后遍历过程中，遇到了key 值相等的数据，直接更新即可。
4. 槽位数据不为空，往后遍历过程中，在找到Entry为null的槽位之前，遇到key过期的Entry，即key=null：
   Entry数据key为null，表明此数据key值已经被垃圾回收掉了，此时就会执行replaceStaleEntry()方法，该方法含义是替换过期数据的逻辑，以index作为起点开始遍历，进行探测式数据清理工作。
   向前迭代查找，for循环迭代，直到碰到Entry为null（第一个槽位）结束。
   向后迭代，如果找到了相同 key 值的 Entry 数据。更新Entry的值并交换staleSlot元素位置。向后遍历过程中，如果没有找到相同 key 值的 Entry 数据，就直到Entry为null停止寻找。

清理工作主要是有两个方法：expungeStaleEntry()和cleanSomeSlots()

ThreadLocalMap过期 key 的探测式清理流程

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

ThreadLocalMap扩容机制

在ThreadLocalMap.set()方法的最后，如果执行完启发式清理工作后，未清理到任何数据，且当前散列数组中Entry的数量已经达到了列表的扩容阈值(len*2/3)，就开始执行rehash()逻辑：
rehash()具体实现：

private void rehash() {expungeStaleEntries();if (size >= threshold - threshold / 4)resize();
}private void expungeStaleEntries() {Entry[] tab = table;int len = tab.length;for (int j = 0; j < len; j++) {Entry e = tab[j];if (e != null && e.get() == null)expungeStaleEntry(j);}
}

清理完成之后，table中可能有一些key为null的Entry数据被清理掉，所以此时通过判断size >= threshold - threshold / 4 也就是size >= threshold * 3/4 来决定是否扩容。

ThreadLocalMap.get()详解

1. 第一种情况： 通过查找key值计算出散列表中slot位置，然后该slot位置中的Entry.key和查找的key一致
   直接返回
2. 第二种情况： slot位置中的Entry.key和要查找的key不一致：
   需要继续往后迭代查找。
   如果向后Entry.key=null，触发一次探测式数据回收操作，执行expungeStaleEntry()方法，执行完后，index 的key为空的数据都会被回收，而index 不为空的数据都会前移

源码如下：java.lang.ThreadLocal.ThreadLocalMap.getEntry():

private Entry getEntry(ThreadLocal<?> key) {int i = key.threadLocalHashCode & (table.length - 1);Entry e = table[i];if (e != null && e.get() == key)return e;elsereturn 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);elsei = nextIndex(i, len);e = tab[i];}return null;
}

ThreadLocalMap过期 key 的启发式清理流程

探测式清理是以当前Entry 往后清理，遇到值为null则结束清理，属于线性探测清理。

在添加新元素或删除另一个陈旧元素时调用。它执行对数次扫描，循环 log2n次，如果在循环中发现了 过期key，此时会进行探测式清理，并重置循环次数为 log2n次

InheritableThreadLocal

使用ThreadLocal的时候，在异步场景下是无法给子线程共享父线程中创建的线程副本数据的

JDK 中还有一个InheritableThreadLocal类可以解决该问题：

public class InheritableThreadLocalDemo {public static void main(String[] args) {ThreadLocal<String> ThreadLocal = new ThreadLocal<>();ThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();ThreadLocal.set("父类数据:threadLocal");inheritableThreadLocal.set("父类数据:inheritableThreadLocal");new Thread(new Runnable() {@Overridepublic void run() {System.out.println("子线程获取父类ThreadLocal数据：" + ThreadLocal.get());System.out.println("子线程获取父类inheritableThreadLocal数据：" + inheritableThreadLocal.get());}}).start();}
}
打印：
子线程获取父类ThreadLocal数据：null
子线程获取父类inheritableThreadLocal数据：父类数据:inheritableThreadLocal

inheritableThreadLocal的实现原理：
子线程是通过在父线程中通过调用new Thread()方法来创建子线程，Thread#init方法在Thread的构造方法中被调用。在init方法中拷贝父线程数据到子线程中：

private void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc,boolean inheritThreadLocals) {if (name == null) {throw new NullPointerException("name cannot be null");}if (inheritThreadLocals && parent.inheritableThreadLocals != null)this.inheritableThreadLocals =ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);this.stackSize = stackSize;tid = nextThreadID();
}

InheritableThreadLocal仍然有缺陷，一般做异步化处理都是使用的线程池，而InheritableThreadLocal是在new Thread中的init()方法给赋值的，而线程池是线程复用的逻辑，所以这里会存在问题。当然，有问题出现就会有解决问题的方案，阿里巴巴开源了一个TransmittableThreadLocal组件就可以解决这个问题

ThreadLocal项目实践

现在都是分布式系统统一对外提供服务，项目间调用的关系可以通过 traceId 来关联。不同项目之间传递 traceId 通过org.slf4j.MDC实现，内部通过ThreadLocal实现

当前端发送请求到服务 A时，服务 A会生成一个类似UUID的traceId字符串，将此字符串放入当前线程的ThreadLocal中，在调用服务 B的时候，将traceId写入到请求的Header中，服务 B在接收请求时会先判断请求的Header中是否有traceId，如果存在则写入自己线程的ThreadLocal中。