并发——深入分析ThreadLocal的实现原理
作者：互联网
一、正文
1.1 ThreadLocal是什么
ThreadLocal被称作线程局部变量，当我们定义了一个ThreadLocal变量，所有的线程共同使用这个变量，但是对于每一个线程来说，实际操作的值是互相独立的。简单来说就是，ThreadLocal能让线程拥有自己内部独享的变量。举一个简单的例子：
// 定义一个线程共享的ThreadLocal变量
static ThreadLocal<Integer> tl = new ThreadLocal<>();
public static void main(String[] args) {
// 创建第一个线程
Thread t1 = new Thread(() -> {
// 设置ThreadLocal变量的初始值，为1
tl.set(1);
// 循环打印ThreadLocal变量的值
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "----" + tl.get());
// 每次打印完让值 + 1
tl.set(tl.get() + 1);
}
}, "thread1");
// 创建第二个线程
Thread t2 = new Thread(() -> {
// 设置ThreadLocal变量的初始值，为100，与上一个线程区别开
tl.set(100);
// 循环打印ThreadLocal变量的值
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "----" + tl.get());
// 每次打印完让值 - 1
tl.set(tl.get() - 1);
}
}, "thread2");
// 开启两个线程
t1.start();
t2.start();
tl.remove();
}上面的代码，运行结果如下（注：每次运行的结果可能不同）：
thread1----1
thread2----100
thread1----2
thread2----99
thread1----3
thread2----98
thread1----4
thread2----97
thread1----5
thread2----96
thread1----6
thread2----95
thread1----7
thread2----94
thread1----8
thread2----93
thread1----9
thread2----92
thread1----10
thread2----91通过上面的输出结果我们可以发现，线程1和线程2虽然使用的是同一个ThreadLocal变量存储值，但是输出结果中，两个线程的值却互不影响，线程1从1输出到10，而线程2从100输出到91。这就是ThreadLocal的功能，即让每一个线程拥有自己独立的变量，多个线程之间互不影响。
1.2 ThreadLocal的实现原理
下面我就就来说一说ThreadLocal是如何做到线程之间相互独立的，也就是它的实现原理。这里我直接放出结论，后面再根据源码分析：每一个线程都有一个对应的Thread对象，而Thread类有一个成员变量，它是一个Map集合，这个Map集合的key就是ThreadLocal的引用，而value就是当前线程在key所对应的ThreadLocal中存储的值。当某个线程需要获取存储在ThreadLocal变量中的值时，ThreadLocal底层会获取当前线程的Thread对象中的Map集合，然后以ThreadLocal作为key，从Map集合中查找value值。这就是ThreadLocal实现线程独立的原理。也就是说，ThreadLocal能够做到线程独立，是因为值并不存在ThreadLocal中，而是存储在线程对象中。下面我们根据ThreadLocal中两个最重要的方法来确认这一点。
1.3 ThreadLocal的get方法
get方法的作用非常简单，就是线程向ThreadLocal中取值，下面我们来看看它的源码：
public T get() {
// 获取当前线程的Thread对象
Thread t = Thread.currentThread();
// getMap方法传入Thread对象，此方法将返回Thread对象中存储的一个Map集合
// 这个Map集合的类型为ThreadLocalMap，这是ThreadLoacl的一个内部类
// 当前线程存放在ThreadLocal中的值，实际上存放在这个Map集合中
ThreadLocalMap map = getMap(t);
// 如果当前Map集合已经初始化，则直接从Map集合中查找
if (map != null) {
// ThreadLocalMap的key其实就是ThreadLoacl对象的引用
// 所以要找到线程在当前ThreadLoacl中存放的值，就需要以当前ThreadLoacl作为key
// getEntry方法就是通过key获取map中的一个key-value，而这里使用的key就是this
ThreadLocalMap.Entry e = map.getEntry(this);
// 如果返回值不为空，表示查找成功
if (e != null) {
@SuppressWarnings("unchecked")
// 于是获取对应的value并返回
T result = (T)e.value;
return result;
}
}
// 若当前线程的ThreadLocalMap还未初始化，或者查找失败，则调用以下方法
return setInitialValue();
}
private T setInitialValue() {
// 此方法默认返回null，但是可以由子类进行重新，根据需求返回需要的值
T value = initialValue();
// 获取当前线程的Thread对象
Thread t = Thread.currentThread();
// 获取对应的ThreadLocalMap
ThreadLocalMap map = getMap(t);
// 如果Map已经初始化了，就直接往map中加入一个key-value
// key就是当前ThreadLocal对象的引用，而value就是上面获取到的value，默认为null
if (map != null)
map.set(this, value);
// 若还没有初始化，则调用createMap创建ThreadLocalMap对象
else
createMap(t, value);
// 返回initialValue方法返回的值，默认为null
return value;
}
void createMap(Thread t, T firstValue) {
// 创建ThreadLocalMap对象，构造方法传入的是第一对放入其中的key-value
// 这个key也就是当前线程第一次调用get方法的ThreadLocal对象，也就是当前ThreadLocal对象
// 而firstValue则是initialValue方法的返回值，默认为null
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
上面的代码非常直观的验证了我之前说过的ThreadLocal的实现原理。通过上面的代码，我们可以非常直观的看到，线程向ThreadLocal中存放的值，最后都放入了线程自己的ThreadLocalMap中，而这个map的key就是当前ThreadLocal的引用。而ThreadLocal中，获取线程的ThreadLocalMap的方法getMap的代码如下：
ThreadLocalMap getMap(Thread t) {
// 直接返回Thread对象的threadLocals成员变量
return t.threadLocals;
}我们再看看Thread类中的threadLocals变量：
/** 可以看到，ThreadLocalMap是ThreadLocal的内部类 */
ThreadLocal.ThreadLocalMap threadLocals = null;1.4 ThreadLocal中的set方法
下面再来看一看ThreadLocal的set方法的实现，set方法用来使线程向ThreadLocal中存放值（实际上是存放在线程自己的Map中）：
public void set(T value) {
// 获取当前线程的Thread对象
Thread t = Thread.currentThread();
// 获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
// 若map已经初始化，则之际将value放入Map中，对应的key就是当前ThreadLocal的引用
if (map != null)
map.set(this, value);
// 若没有初始化，则调用createMap方法，为当前线程t创建ThreadLocalMap，
// 然后将key-value放入（此方法已经在上面讲解get方法是看过）
else
createMap(t, value);
}
这就是set方法的实现，比较简单。看完上面两个关键方法的实现，相信大家对ThreadLocal的实现已经有了一个比较清晰的认识，下面我们来更加深入的分析ThreadLocal，看看ThreadLocalMap的一些实现细节。
1.5 ThreadLocalMap中的弱引用
ThreadLocalMap的实现其实就是一个比较普通的Map集合，它的实现和HashMap类似，所以具体的实现细节我们就不一一讲解了，这里我们只关注它最特别的一个地方，即它内部的节点Entry。我们先来看看Entry的代码：
// Entry是ThreadLocalMap的内部类，表示Map的节点
// 这里继承了WeakReference，这是java实现的弱引用类，泛型为ThreadLocal
// 表示在这个Map中，作为key的ThreadLocal是弱引用
// （这里value是强引用，因为没用WeakReference）
static class Entry extends WeakReference<ThreadLocal<?>> {
/** 存储value */
Object value;
Entry(ThreadLocal<?> k, Object v) {
// 将key的值传入父类WeakReference的构造方法，用弱引用来引用key
super(k);
// value则直接使用上面的强引用
value = v;
}
}可以看到，上面的Entry比较特殊，它继承自WeakReference类型，这是Java实现的弱引用。在具体讲解前，我们先来介绍一下不同类型的引用：
强引用：这是Java中最常见的引用，在没有使用特殊引用的情况下，都是强引用，比如Object o = new Object()就是典型的强引用。能让程序员通过强引用访问到的对象，不会被JVM垃圾回收，即使内存空间不够，JVM也不会回收这些对象，而是抛出内存溢出异常；
软引用：软引用描述的是一些还有用，但不是必须的对象。被软引用所引用的对象，也不会被垃圾回收，直到JVM将要发生内存溢出异常时，才会将这些对象列为回收对象，进行回收。在JDK1.2之后，提供了SoftReference类实现软引用；
弱引用：弱引用描述的是非必须的对象，被弱引用所引用的对象，只能生存到下一次垃圾回收前，下一次垃圾回收来临，此对象就会被回收。在JDK1.2之后，提供了WeakReference类实现弱引用（也就是上面Entry继承的类）；
虚引用：这是最弱的一种引用关系，一个对象是否有虚引用，完全不会对其生存时间产生影响，我们也不能通过一个虚引用访问对象，使用虚引用的唯一目的就是，能在这个对象被回收时，受到一个系统的通知。JDK1.2之后，提供了PhantomReference实现虚引用；
介绍完各类引用的概念，我们就可以来分析一下Entry为什么需要继承WeakReference类了。从代码中，我们可以看到，Entry将key值，也就是ThreadLocal的引用传入到了WeakReference的构造方法中，也就是说在ThreadLocalMap中，key的引用是弱引用。这表明，当没有其他强引用指向key时，这个key将会在下一次垃圾回收时被JVM回收。
为什么需要这么做呢？这么做的目的自然是为了有利于垃圾回收了。如果了解过JVM的垃圾回收算法的应该知道，JVM判断一个对象是否需要被回收，判断的依据是这个对象还能否被我们所使用，举个简单的例子：
public static void main(String[] args) {
Object o = new Object();
o = null;
}
上面的代码中，我们创建了一个对象，并使用强引用o指向它，然后我们将o置为空，这个时候刚刚创建的对象就丢失了，因为我们无法通过任何引用找到这个对象，从而使用它，于是这个对象就需要被回收，这种判断依据被称为可达性分析。关于JVM的垃圾回收算法，可以参考这篇博客：Java中的垃圾回收算法详解。
好，回归正题，我们开始分析为什么ThreadLocalMap需要让key使用弱引用。假设我们创建了一个ThreadLocal，使用完之后没有用了，我们希望能够让它被JVM回收，于是有了下面这个过程：
// 创建ThreadLocal对象
ThreadLocal tl = new ThreadLocal();
// .....省略使用的过程...
// 使用完成，希望被JVM回收，于是执行以下操作，解除强引用
tl = null;我们在使用完ThreadLocal之后，解除对它的强引用，希望它被JVM回收。但是JVM无法回收它，因为我们虽然在此处释放了对它的强引用，但是它还有其它强引用，那就是Thread对象的ThreadLocalMap的key。我们之前反复说过，ThreadLocalMap的key就是ThreadLocal对象的引用，若这个引用是一个强引用，那么在当前线程执行完毕，被回收前，ThreadLocalMap不会被回收，而ThreadLocalMap不会被回收，它的key引用的ThreadLocal也就不会回收，这就是问题的所在。而使用弱引用就可以保证，在其他对ThreadLocal的强引用解除后，ThreadLocalMap对它的引用不会影响JVM对它进行垃圾回收。这就是使用弱引用的原因。
1.6 ThreadLocal造成的内存溢出的问题
上面描述了对ThreadLocalMap对key使用弱引用，来避免JVM无法回收ThreadLocal的问题，但是这里却还有另外一个问题。我们看上面Entry的代码发现，key值虽然使用的弱引用，但是value使用的却是强引用。这会造成一个什么问题？这会造成key被JVM回收，但是value却无法被收，key对应的ThreadLocal被回收后，key变为了null，但是value却还是原来的value，因为被ThreadLocalMap所引用，将无法被JVM回收。若value所占内存较大，线程较多的情况下，将持续占用大量内存，甚至造成内存溢出。我们通过一段代码演示这个问题：
public class Main {
public static void main(String[] args) {
// 循环创建多个TestClass
for (int i = 0; i < 100; i++) {
// 创建TestClass对象
TestClass t = new TestClass(i);
// 调用反复
t.printId();
// *************注意此处，非常关键：为了帮助回收，将t置为null
t = null;
}
}
static class TestClass {
int id;
// 每个TestClass对象对应一个很大的数组
int[] arr = new int[100000000];
// 每个TestClass对象对应一个ThreadLocal对象
ThreadLocal<int[]> threadLocal = new ThreadLocal<>();
TestClass(int id) {
this.id = id;
// threadLocal存放的就是这个很大的数组
threadLocal.set(arr);
}
public void printId() {
System.out.println(id);
}
}
}上面的代码多次创建所占内存非常大的对象，并在创建后，立即解除对象的强引用，让对象可以被JVM回收。按道理来说，上面的代码运行应该不会发生内存溢出，因为我们虽然创建了多个大对象，占用了大量空间，但是这些对象立即就用不到了，可以被垃圾回收，而这个对象被垃圾回收后，对象的id，数组，和threadLocal成员都会被回收，所以所占内存不会持续升高，但是实际运行结果如下：
0
1
2
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at Main$TestClass.<init>(Main.java:23)
at Main.main(Main.java:10)可以看到，很快就发生了内存溢出异常。为什么呢？需要注意到，在TestClass的构造方法中，我们将数组arr放入了ThreadLocal对象中，也就是被放进了当前线程的ThreadLocalMap中，作为value存在。我们前面说过，ThreadLocalMap的value是强引用，这也就意味着虽然ThreadLocal可以被正常回收，但是作为value的大数组无法被回收，因为它仍然被ThreadLocalMap的强引用所指向。于是TestClass对象的超大数组就一种在内存中，占据大量空间，我们连续创建了多个TestClass，内存很快就被占满了，于是发生了内存溢出。而JDK的开发人员自然发现了这个问题，于是有了下面这个解决方案：
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
TestClass t = new TestClass(i);
t.printId();
// **********注意，与上面的代码只有此处不同************
// 此处调用了ThreadLocal对象的remove方法
t.threadLocal.remove();
t = null;
}
}
static class TestClass {
int id;
int[] arr;
ThreadLocal<int[]> threadLocal;
TestClass(int id) {
this.id = id;
arr = new int[100000000];
threadLocal = new ThreadLocal<>();
threadLocal.set(arr);
}
public void printId() {
System.out.println(id);
}
}
}
上面的代码中，我们在将t置为空时，先调用了ThreadLocal对象的remove方法，这样做了之后，再看看运行结果：
0
1
2
// ....神略中间部分
98
99做了上面的修改后，没有再发生内存溢出异常，程序正常执行完毕。这是为什么呢？ThreadLocal的remove方法究竟有什么作用。其实remove方法的作用非常简单，执行remove方法时，会从当前线程的ThreadLocalMap中删除key为当前ThreadLocal的那一个记录，key和value都会被置为null，这样一来，就解除了ThreadLocalMap对value的强引用，使得value可以正常地被JVM回收了。所以，今后如果我们确认不再使用的ThreadLocal对象，一定要记得调用它的remove方法。
我们之前说过，如果我们没有调用remove方法，那就会导致ThreadLocal在使用完毕后，被正常回收，但是ThreadLocalMap中存放的value无法被回收，此时将会在ThreadLocalMap中出现key为null，而value不为null的元素。为了减少已经无用的对象依旧占用内存的现象，ThreadLocal底层实现中，在操作ThreadLocalMap的过程中，线程若检测到key为null的元素，会将此元素的value置为null，然后将这个元素从ThreadLocalMap中删除，占用的内存就可以让JVM将其回收。比如说在getEntry方法中，或者是Map扩容的方法中等。
二、总结
ThreadLocal实现线程独立的方式是直接将值存放在Thread对象的ThreadLocalMap中，Map的key就是ThreadLocal的引用，且为了有助于JVM进行垃圾回收，key使用的是弱引用。在使用ThreadLocal后，一定要记得调用remove方法，有助于JVM对value的回收。
三、参考
- 《深入理解Java虚拟机（第二版）》
- ThreadLocal面试六连问，你能Hold住吗？
- 并发——深入分析ThreadLocal的实现原理
标签：ThreadLocalMap,value,并发,ThreadLocal,线程,引用,key,深入分析 来源： https://blog.csdn.net/qq_33371766/article/details/121870308