Java中ThreadLocal详解（一篇就够了）
前言
ThreadLocal直译为线程局部变量，或许将它命名为ThreadLocalVariable更为合适。其主要作用就是实现线程本地存储功能，通过线程本地资源隔离，解决多线程并发场景下线程安全问题。
ThreadLocal
接下来，通过ThreadLocal的使用案例、应用场景、源码分析来进行深层次的剖析，说明如何避免使用中出现问题以及解决方案。
使用案例
前面提到关于ThreadLocal的线程隔离性，通过下面一个简单的例子来演示ThreadLocal的隔离性。
package com.starsray.test.tl;
import java.util.ArrayList;
import java.util.List;
public class ThreadLocalTest {
// 声明一个ThreadLocal成员变量
private final ThreadLocal tl = new ThreadLocal<>();
// 声明一个List作为参照对象
private final List list = new ArrayList<>();
public static void main(String[] args) {
new ThreadLocalTest().test();
}
public void test() {
// 创建测试Person对象
Person person = new Person();
person.setName("张三");
person.setAge(24);
// 创建线程一：再启动1s后，分别添加person对象到tl、list对象中
new Thread(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
tl.set(person);
list.add(person);
System.out.println(Thread.currentThread().getName() + " [thread] get():" + tl.get());
System.out.println(Thread.currentThread().getName() + " [list] get():" + list.get(0));
},"thread-1").start();
// 创建线程二：在启动2s后，分别去tl、list对象中取person对象
new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " [thread] get():" + tl.get());
System.out.println(Thread.currentThread().getName() + " [list] get():" + list.get(0));
},"thread-2").start();
}
// 测试静态内部类Person
static class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
} 案例中使用两个线程同时对List和ThreadLocal对象进行操作，通过对照实验，从输出结果可以看到，ThreadLocal实现了线程间数据隔离，这也说明每一个Thread对象维护了自己的一份数据。
hread-1 [thread] get():Person{name='张三', age=24}
thread-1 [list] get():Person{name='张三', age=24}
thread-2 [thread] get():null
thread-2 [list] get():Person{name='张三', age=24}应用场景
针对ThreadLocal而言，由于其适合隔离、线程本地存储等特性，因此天然的适合一些Web应用场景，比如下面所列举的例子：
- 代替参数显式传递(很少使用)
- 存储全局用户登录信息
- 存储数据库连接，以及Session等信息
- Spring事务处理方案
源码分析
通过使用案例的展示，接下来对ThreadLocal的实现原理进行简单分析。
WeakReference
在对ThreadLocal的源码展开描述之前，首先简单提一下Java中四种引用类型，强、软、若、虚之一的弱引用，这四种引用关系引用程度依次降低。Java中弱引用通过WeakReference表示，在JDK1.2引入。
public class WeakReference extends Reference {
// 创建一个给定类型的对象弱引用
public WeakReference(T referent) {
super(referent);
}
// 创建一个给定类型的对象弱引用，并注册到队列
public WeakReference(T referent, ReferenceQueue q) {
super(referent, q);
}
} 弱引用用来描述非必须对象，被弱引用关联的对象只能生存到下一次垃圾收集发生为止。如果发生垃圾收集，无论内存空间是否满足，都会回收掉被弱引用关联的对象。
例如下面代码模拟，为了便于模拟出效果，指定虚拟机启动参数：-Xms4m -Xmx4m
public class WeakRefTest {
@Override
protected void finalize() {
System.out.println("gc");
}
public static void main(String[] args) {
for (int i = 0; i < 500; i++) {
WeakRefTest weakRefTest = new WeakRefTest();
new WeakReference<>(weakRefTest);
if (i >= 450) {
System.gc();
}
}
}
}- finalize()是Object方法，当虚拟机在回收对象时，允许执行完该方法后再进行回收
- System.gc()会通知虚拟机进行垃圾回收，并不会立即进行垃圾回收
执行结果：
gc
...关于弱引用的特性，为什么ThreadLocal中要使用弱引用来维护一个对象，后面会继续进行描述。
ThreadLocalMap
ThreadLocalMap是ThreadLocal的一个静态内部类。每一个Thread对象实例中都维护了ThreadLocalMap对象，对象本质存储了一组以ThreadLocal为key(this对象实际使用的是唯一threadLocalHashCode值)，以本地线程包含变量为value的K-V键值对。
在ThreadLocalMap内部还维护了一个Entry静态内部类，该类继承了WeakReference，并指定其所引用的泛型类为ThreadLocal类型。Entry是一个键值对结构，使用ThreadLocal类型对象作为引用的key。
static class Entry extends WeakReference> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
} 查看Entry源码。Entry之所以使用数组结构，一个Thread在运行的过程中会存在多个ThreadLocal对象的场景，ThreadLocalMap作为ThreadLocal的静态内部类，需要维护多个ThreadLocal对象所存储的value值。
// 初始化默认容量为 16
private static final int INITIAL_CAPACITY = 16;
// 数据存储结构底层实现为Entry数组，其长度必须为2的倍数
private Entry[] table;
// table中Entry的实际数量，初始值为0
private int size = 0;
// 存储的阈值
private int threshold; // Default to 0
// resize扩容阈值加载因子为2/3
private void setThreshold(int len) {
threshold = len * 2 / 3;
}整个ThreadLocal类中核心内容都是对ThreadLocalMap进行操作，而ThreadLocalMap的核心内容都是围绕Entry组成的Map存储结构进行操作。关于ThreadLocal、ThreadLocalMap、Entry之间的关系如图所示：
ThreadLocal对象是当前线程的ThreadLocalMap的访问入口，Thread类中维护了两个关于ThreadLocalMap的成员变量。
// ThreadLocal变量
ThreadLocal.ThreadLocalMap threadLocals = null;
// InheritableThreadLocal变量，该类继承自ThreadLocal
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;threadLocals在Thread类中作为成员变量，初始化线程对象时并不会被赋予值，只有在使用ThreadLocal时进行赋值。查看ThreadLocal中的get方法
public T get() {
// 获取当前操作线程
Thread t = Thread.currentThread();
// 调用getMap方法，返回当前线程的实例变量threadLocals值
ThreadLocalMap map = getMap(t);
// 如果返回map不为空，返回map中所存储的以当前ThreadLocal对象为key的值
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
// 如果map为空进行map值的初始化
return setInitialValue();
}
ThreadLocalMap getMap(Thread t) {
// 返回传入线程(当前线程)中成员变量的threadLocals值
return t.threadLocals;
}
private T setInitialValue() {
// 调用initialValue()方法设置初始值，默认不设置任何值，可以在创建ThreadLocal
// 对象时被重写进行初始化，只会进行一次初始化。
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
void createMap(Thread t, T firstValue) {
// 初始化当前线程对象实例变量threadLocals的值，Map所对应的key为当前ThreadLocal对象
t.threadLocals = new ThreadLocalMap(this, firstValue);
}接下来查看set方法
public void set(T value) {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 调用getMap方法，传入当前对象的值，获取当前线程的实例变量threadLocals值
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
// 如果map为空，创建ThreadLocalMap
createMap(t, value);
}而inheritableThreadLocals会在创建线程时，根据线程构造方法传参，确定是否进行初始化。
// 该init方法为Thread内部线程初始化方法，inheritThreadLocals是否继承父类变量，默认false
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals);
// 如果inheritThreadLocals为true并且parent(为当前线程，视为要被继承线程的父线程)
// 的ThreadLocal不为null，调用createInheritedMap方法进行继承初始化
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
// 为子线程创建一个新的ThreadLocalMap并初始化parentMap中的变量实现继承
static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
return new ThreadLocalMap(parentMap);
}threadLocalHashCode
在ThreadLocal的成员变量中包含了`threadLocalHashCode`和`HASH_INCREMENT`两个成员变量：
private final int threadLocalHashCode = nextHashCode();
// 连续生成的哈希码之间的差异
// 将隐式顺序线程本地 ID 转换为接近最佳传播的乘法哈希值，用于二次幂大小的表
private static final int HASH_INCREMENT = 0x61c88647;关于threadLocalHashCode的解释：
ThreadLocals 依赖于附加到每个线程（Thread.threadLocals 和inheritableThreadLocals）的每线程线性探针哈希映射。 ThreadLocal 对象充当键，通过 threadLocalHashCode 进行搜索。这是一个自定义哈希码（仅在 ThreadLocalMaps 中有用），它消除了在相同线程使用连续构造的 ThreadLocals 的常见情况下的冲突，同时在不太常见的情况下保持良好行为。
HASH_INCREMENT`是用来计算下一个哈希码（threadLocalHashCode）的哈希魔数，源码中用十六进制表示，其对应的十进制数为1640531527，至于为什么是这个数值并不是偶然，而是这个数在有符号的int范围内是黄金分割数。
如下代码所示，输出的结果刚好是`-1640531527`,也就是说是32位有符号整数的黄金分割值。
public static void main(String[] args) {
long c = (long) ((1L << 32) * (Math.sqrt(5) - 1) / 2);
System.out.println(c);
//强制转换为带符号为的32位整型，值为-1640531527
int i = (int) c;
System.out.println(i);
System.out.println(Integer.MAX_VALUE);
}ThreadLocal在ThreadLocalMap中是根据ThreadLocal对象的threadLocalHashCode进行索引的，查看下面一段源码，从源码可以看到在Entry表里求下标的算法为：
哈希key：keyIndex = key.threadLocalHashCode & (table.length - 1);
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);
}哈希key的求值也可以看作：keyIndex = ((i + 1) * HASH_INCREMENT) & (length - 1)，i为ThreadLocal实例的个数，HASH_INCREMENT是哈希魔数0x61c88647，length为ThreadLocalMap中可容纳的Entry的容量。初始容量为16，扩容后总是2的幂次方。
下面做个测试为什么使用HASH_INCREMENT作为魔数，以及求取下标的算法巧妙之处：
public class TestThreadLocalHashCode {
public static void main(String[] args) {
hashCode(4);
hashCode(16);
hashCode(32);
hashCode(64);
}
private static void hashCode(int capacity) {
final int HASH_INCREMENT = 0x61c88647;
final AtomicInteger nextHashCode = new AtomicInteger(HASH_INCREMENT);
int keyIndex;
for (int i = 0; i < capacity; i++) {
keyIndex = nextHashCode.getAndAdd(HASH_INCREMENT) & (capacity - 1);
// keyIndex = ((i + 1) * HASH_INCREMENT) & (capacity - 1);
System.out.print(keyIndex + " ");
}
System.out.println();
}
}在不触发二次扩容的场景下，每个`ThreadLocalMap`中的元素分别为4，16，32，64，输出结果：
3 2 1 0
7 14 5 12 3 10 1 8 15 6 13 4 11 2 9 0
7 14 21 28 3 10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25 0
7 14 21 28 35 42 49 56 63 6 13 20 27 34 41 48 55 62 5 12 19 26 33 40 47 54 61 4 11 18 25 32 39 46 53 60 3 10 17 24 31 38 45 52 59 2 9 16 23 30 37 44 51 58 1 8 15 22 29 36 43 50 57 0每组测试在进行散列算法后刚好填满了整个容器，实现了完美散列，这使得ThreadLocal在使用的过程中可以尽可能高的提高在ThreadLocalMap中获取元素的命中率，提高了ThreadLocal在使用中的效率。
此外从输出结果来看，ThreadLocal中使用了斐波那契散列法，保证哈希表的离散度。它选用的乘数值即是2^32的黄金分割比0x61c88647。
注意事项
ThreadLocal提供了便利的同时当然也需要注意在使用过程中的一些细节问题。下面进行简单总结
异步调用
ThreadLocal默认情况下不会进行子线程对父线程变量的传递性，在开启异步线程的时候需要注意这一点，关于这一点可以通过Thread类构造方法提供的inheritThreadLocals参数进行封装，或者使用Spring根据装饰器模式进行封装的TaskDecorator类实现跨线程传递方法。
线程池问题
线程池中线程调用使用ThreadLocal 需要注意，由于线程池中对线程管理都是采用线程复用的方法，在线程池中线程非常难结束甚至于永远不会结束，这将意味着线程持续的时间将不可预测。另外重复使用可能导致ThreadLocal
对象未被清理，在ThreadLocalMap中进行值操作时被覆盖，或取到旧值。如下代码所示：
package com.starsray.test.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadLocalPoolTest {
private final static ThreadLocal tl = ThreadLocal.withInitial(() -> new AtomicInteger(0));
static class Task implements Runnable{
@Override
public void run() {
System.out.println(tl.get().incrementAndGet());
}
}
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);
for (int i = 0; i < 5; i++) {
pool.execute(new Task());
}
pool.shutdown();
}
} 期待的输出结果应该是1，实际输出结果，由于超出后线程被复用，输出结果也会取到旧值。
1
1
2
2
3
3当然，如果必须要在线程池中使用ThreadLocal也不是不能使用，在线程池类ThreadPoolExecutor中定义了钩子函数，可以在初始化或者任务执行完做特殊处理，如初始化ThreadLocal或者记录日志。重写beforeExecute方法：
protected void beforeExecute(Thread t, Runnable r) { }内存泄露
ThreadLocal对象不仅提供了get、set方法，还提供了remove方法。虽然get、set已经对空值进行清理，但在实际使用时，手动调用remove方法养成良好的编程习惯是非常有必要的。
ThreadLocal中主要的存储单元Entry类继承了WeakReference，该类的引用在虚拟机进行GC时会被进行清理，但是对于value如果是强引用类型，就需要进行手动remove，避免value的内存泄露。关于引用关系参考下图所示：
关于内存泄露这块的重点在于两部分：
- ThreadLocal被一强(tl = new强引用)一弱(WeakReference
- 关于value部分的引用，如果是强引用类型的value通过remove方法可以清理，避免内存泄露。
具体细节查看remove部分的源码：
public void remove() {
// 获取当前线程中threadLocals对应的ThreadLocalMap
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
// 如果ThreadLocalMap不为空，继续调用remove(this)方法
m.remove(this);
}查看remove(this)具体内容
private void remove(ThreadLocal key) {
// 创建新都tab数组，引用指向当前ThreadLocal对象中的table
Entry[] tab = table;
// tab的长度
int len = tab.length;
// 根据当前ThreadLocal对象的唯一threadLocalHashCode值并通过与操作
// 获取当前ThreadLocal对象在table中value所在的下标值i
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
// 对table进行遍历，如果Entry所对应的key为当前ThreadLocal对象，执行clear方法
if (e.get() == key) {
// 将引用置为null
e.clear();
// 清楚陈旧的键值对
expungeStaleEntry(i);
return;
}
}
}查看clear()方法，Clear方法位于Reference类中，由于Entry类继承了WeakReference(继承WeakReference)，此处的clear属于多态的应用。
public void clear() {
this.referent = null;
}接下来expungStaleEntry(i)方法则是整个remove的核心逻辑了，这里首先再明确以下两个变量的意义：
- size：前面提到size是Entry的数量，即ThreadLocal中成员变量table的实际键值对数量
- i：table中与当前ThreadLocal对象相匹配的Entry的key值的下标
private int expungeStaleEntry(int staleSlot) {
// 创建新都tab数组，引用指向当前ThreadLocal对象中的table
Entry[] tab = table;
// tab的长度
int len = tab.length;
// 将tab中下标staleSlot(i)对应的value引用置为null
tab[staleSlot].value = null;
// 将tab中下标staleSlot的Entry置为null
tab[staleSlot] = null;
// Entry对应的长度减1
size--;
// Rehash until we encounter null 直到遇到null开始rehash
Entry e;
int i;
// 从staleSlot后以索引开始遍历，直到遇到某个Entry不为空为止
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
// 获取Entry对应的ThreadLocal对象的引用key值
ThreadLocal k = e.get();
if (k == null) {
// 如果为空，将value和键值对同时置空，size减1
e.value = null;
tab[i] = null;
size--;
} else {
// 如果k不为null，说明弱引用未被GC回收，获取table中k对应的下标
int h = k.threadLocalHashCode & (len - 1);
// 判断传入下标，与当前k对象的下标是否一直
if (h != i) {
// 如果不一致，需要对tab中的值进行更新，直接清空
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
while (tab[h] != null)
// 采用R算法的变种，从当前h开始寻找一个为null的值存储e
h = nextIndex(h, len);
tab[h] = e;
}
}
}
// 返回第一个entry为null的下标
return i;
}关于expungeStaleEntry中原作者对关键地方进行了英文注释，源码提及了Knuth 6.4 Algorithm R算法，R算法主要说明了如何从使用线性探测的散列表中删除一个元素。
与Knuth 6.4算法R不同，这里必须扫描到null，可能出现空的Entry，多个条目可能已经过时，由于不使用引用队列，因此只有在表开始空间不足时才能保证删除过时的条目。
总结
Thread对象中通过维护了一个ThreadLocal.ThreadLocalMap类型的threadLocals变量实现线程间变量隔离，并维护了一个ThreadLocal.ThreadLocalMap类型的inheritableThreadLocals变量实现线程间变量的继承，是否继承由线程初始化时inheritThreadLocals参数进行决定，默认不继承。
ThreadLocal中核心存储的类为ThreadLocalMap类，ThreadLocalMap类本身是一个定制化的Map，这个Map以当前ThreadLocal对象作为key值进行K-V存储。ThreadLocalMap的初始化容量为16，扩容因子为2/3。
ThreadLocalMap在进行存储时，会获取当前this对象的threadLocalHashCode值(这也是为什么使用ThreadLocal作为key的原因)，该值是唯一的，只在ThreadLocalMap中有用，使用Unsafe提供的AtomicInt类操作获取。
ThreadLocalMap中进行存储的基本单位为Entry数组，数组下标通过threadLocalHashCode进行&运算并根据当前数组长度进行自动扩容。
说明：为什么ThreadLocal的key要使用当前ThreadLocal对象或者说是threadLocalHashCode的值，而不是使用当前线程对象？
一个ThreadLocal对象只会对应一个线程对象，但是一个Thread对象会存在多个ThreadLocal对象，之所以不使用Thread对象作为key，是为了避免多个ThreadLocal对象(或者说T、、hreadLocalMap)之间的互相影响。