转载自一下连接：https://www.cnblogs.com/fsmly/p/11020641.html#_label4
对原文进行润色和重点加粗，外加一点点修改
一、ThreadLocal简介
多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。
ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建一乐ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题，如下图所示
二、ThreadLocal简单使用
下面的例子中，开启两个线程，在每个线程内部设置了本地变量的值，然后调用print方法打印当前本地变量的值。如果在打印之后调用本地变量的remove方法会删除本地内存中的变量，代码如下所示
package test;
public class ThreadLocalTest {
static ThreadLocal localVar = new ThreadLocal<>();
static void print(String str) {
//打印当前线程中本地内存中本地变量的值
System.out.println(str + " :" + localVar.get());
//清除本地内存中的本地变量
localVar.remove();
}
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
//设置线程1中本地变量的值
localVar.set("localVar1");
//调用打印方法
print("thread1");
//打印本地变量
System.out.println("after remove : " + localVar.get());
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
//设置线程1中本地变量的值
localVar.set("localVar2");
//调用打印方法
print("thread2");
//打印本地变量
System.out.println("after remove : " + localVar.get());
}
});
t1.start();
t2.start();
}
}
下面是运行后的结果：
三、ThreadLocal的实现原理
下面是ThreadLocal的类图结构，从图中可知：Thread类中有两个变量threadLocals和inheritableThreadLocals，二者都是ThreadLocal内部类ThreadLocalMap类型的变量，我们通过查看内部内ThreadLocalMap可以发现实际上它类似于一个HashMap。在默认情况下，每个线程中的这两个变量都为null
1、set方法源码
public void set(T value) {
//(1)获取当前线程（调用者线程）
Thread t = Thread.currentThread();
//(2)getMap(t)返回当前线程的ThreadLocalMap类型的变量:return t.threadLocals;
ThreadLocalMap map = getMap(t);
//(3)如果map不为null，就直接为当前线程添加本地变量，key为当前定义的ThreadLocal变量的this引用，值为添加的本地变量值
//当线程第一次调用的时候，threadLocals默认是为null的。所以会走createMap
if (map != null)
map.set(this, value);
else
//(4)如果map为null，说明首次添加，需要首先创建出对应的map并初始化赋值给当前线程
createMap(t, value);
}
void createMap(Thread t, T firstValue) {
//创建ThreadLocalMap并初始化然后赋值给当前线程
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
2、get方法源码
在get方法的实现中，首先获取当前调用者线程，如果当前线程的threadLocals不为null，就直接返回当前线程绑定的本地变量值，否则执行setInitialValue方法初始化threadLocals变量。在setInitialValue方法中，类似于set方法的实现，都是判断当前线程的threadLocals变量是否为null，是则添加本地变量（这个时候由于是初始化，所以添加的值为null），否则创建threadLocals变量，同样添加的值为null。
public T get() {
//(1)获取当前线程
Thread t = Thread.currentThread();
//(2)获取当前线程的threadLocals变量
ThreadLocalMap map = getMap(t);
//(3)如果threadLocals变量不为null，就可以在map中查找到本地变量的值
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//(4)执行到此处，threadLocals为null，调用该更改初始化当前线程的threadLocals变量
return setInitialValue();
}
private T setInitialValue() {
//protected T initialValue() {return null;}
T value = initialValue();
//获取当前线程
Thread t = Thread.currentThread();
//以当前线程作为key值，去查找对应的线程变量，找到对应的map
ThreadLocalMap map = getMap(t);
//如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值
if (map != null)
map.set(this, value);
//如果map为null，说明首次添加，需要首先创建出对应的map
else
createMap(t, value);
return value;
}
3、remove方法的实现
remove方法判断该当前线程对应的threadLocals变量是否为null，不为null就直接删除当前线程中指定的threadLocals变量
[ThreadLocal.java]
public void remove() {
//获取当前线程绑定的threadLocals
ThreadLocalMap m = getMap(Thread.currentThread());
//如果map不为null，就移除当前线程中指定ThreadLocal实例的本地变量
if (m != null)
m.remove(this);
}
[ThreadLocal.ThreadLocalMap.java]
491 private void remove(ThreadLocal key) {
492 Entry[] tab = table;
493 int len = tab.length;
494 int i = key.threadLocalHashCode & (len-1);
495 for (Entry e = tab[i];
496 e != null;
497 e = tab[i = nextIndex(i, len)]) {
498 if (e.get() == key) {
499 e.clear();
500 expungeStaleEntry(i);
501 return;
502 }
503 }
504 }
4、如下图所示：每个线程内部有一个名为threadLocals的成员变量，该变量的类型为ThreadLocal.ThreadLocalMap类型（类似于一个HashMap），其中的key为当前定义的ThreadLocal变量的this引用，value为我们使用set方法设置的值。每个线程的本地变量存放在自己的本地内存变量threadLocals中，如果当前线程一直不消亡，那么这些本地变量就会一直存在（所以可能会导致内存溢出），因此使用完毕需要将其remove掉。
ThreadLocal不支持继承性,InheritableThreadLocal类支持继承使用较少暂不讨论。原博文有写连接在文章顶部。
从ThreadLocalMap看ThreadLocal使用不当的内存泄漏问题
1、基础概念
首先我们先看看ThreadLocalMap的类图，在前面的介绍中，我们知道ThreadLocal只是一个工具类，他为用户提供get、set、remove接口操作实际存放本地变量的threadLocals（调用线程的成员变量），也知道threadLocals是一个ThreadLocalMap类型的变量，下面我们来看看ThreadLocalMap这个类。在此之前，我们回忆一下Java中的四种引用类型，相关GC只是参考前面系列的文章(JVM相关)
①强引用：Java中默认的引用类型，一个对象如果具有强引用那么只要这种引用还存在就不会被GC。
②软引用：简言之，如果一个对象具有弱引用，在JVM发生OOM之前（即内存充足够使用），是不会GC这个对象的；只有到JVM内存不足的时候才会GC掉这个对象。软引用和一个引用队列联合使用，如果软引用所引用的对象被回收之后，该引用就会加入到与之关联的引用队列中
③弱引用（这里讨论ThreadLocalMap中的Entry类的重点）：如果一个对象只具有弱引用，那么这个对象就会被垃圾回收器GC掉(被弱引用所引用的对象只能生存到下一次GC之前，当发生GC时候，无论当前内存是否足够，弱引用所引用的对象都会被回收掉)。弱引用也是和一个引用队列联合使用，如果弱引用的对象被垃圾回收期回收掉，JVM会将这个引用加入到与之关联的引用队列中。若引用的对象可以通过弱引用的get方法得到，当引用的对象呗回收掉之后，再调用get方法就会返回null
④虚引用：虚引用是所有引用中最弱的一种引用，其存在就是为了将关联虚引用的对象在被GC掉之后收到一个通知。（不能通过get方法获得其指向的对象）
2、分析ThreadLocalMap内部实现
上面我们知道ThreadLocalMap内部实际上是一个Entry数组,我们先看看Entry的这个内部类
/**
* 是继承自WeakReference的一个类，该类中实际存放的key是
* 指向ThreadLocal的弱引用和与之对应的value值(该value值
* 就是通过ThreadLocal的set方法传递过来的值)
* 由于是弱引用，当get方法返回null的时候意味着线程的key已经被GC清理
*/
static class Entry extends WeakReference> {
/** value就是和ThreadLocal绑定的 */
Object value;
//k：ThreadLocal的引用，被传递给WeakReference的构造方法
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
//WeakReference构造方法(public class WeakReference extends Reference )
public WeakReference(T referent) {
super(referent); //referent：ThreadLocal的引用
}
//Reference构造方法
Reference(T referent) {
this(referent, null);//referent：ThreadLocal的引用
}
Reference(T referent, ReferenceQueue queue) {
this.referent = referent;
this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}
在上面的代码中，我们可以看出，当前ThreadLocal的引用k被传递给WeakReference的构造函数，所以ThreadLocalMap中的key为ThreadLocal的弱引用。当一个线程调用ThreadLocal的set方法设置变量的时候，当前线程的ThreadLocalMap就会存放一个记录，这个记录的key值为ThreadLocal的弱引用，value就是通过set设置的值。如果当前线程一直存在且没有调用该ThreadLocal的remove方法，如果这个时候别的地方还有对ThreadLocal的引用，那么当前线程中的ThreadLocalMap中会存在对ThreadLocal变量的引用和value对象的引用，是不会释放的，就会造成内存泄漏。
考虑这个ThreadLocal变量没有其他强依赖，如果当前线程还存在，由于线程的ThreadLocalMap里面的key是弱引用，所以当前线程的ThreadLocalMap里面的ThreadLocal变量的弱引用在gc的时候就被回收，但是对应的value还是存在的这就可能造成内存泄漏(因为这个时候ThreadLocalMap会存在key为null但是value不为null的entry项)。
总结：THreadLocalMap中的Entry的key使用的是ThreadLocal对象的弱引用，在没有其他地方对ThreadLoca依赖，ThreadLocalMap中的ThreadLocal对象就会被回收掉，但是对应的不会被回收，这个时候Map中就可能存在key为null但是value不为null的项，这需要实际的时候使用完毕及时调用remove方法避免内存泄漏。
原作者java并发相关博文专栏
为什么Entry的key-ThreadLocal被设计成弱引用
ThreadLocal为每一个线程提供了一个私有的变量，这个现象是依托于ThreadLocalMap来实现的，ThreadLocalMap中的每一个Entry的key都是指向了一个threadlocal，这是一个弱引用，当外界对指向threadlocal的强引用回收之后，就说明这个threadlocal就没用了，但是此时当前线程成员变量threadLocals还强引用着ThreadLocalMap。ThreadLocalMap内部的Entry数组还保存着当前线程的ThreadLocal-Value的kv键值对，然而此时当前线程的ThreadLocal已经没用了，所以如果使用强引用那么ThreadLocal和value都得不到释放，从而产生了内存泄漏的问题。于是将Entry类设计成弱引用，若是这个key是一个强引用，那么即使我们将threadlocal置为null，threadlocal也无法释放因为还在Entry数组中被引用着，那么就无法对threadlocal进行回收，就有可能造成一个内存泄漏的问题，所以使用了弱引用来解决这个问题，只有弱引用指向的对象，在下次垃圾回收时就会被回收。此时threadlocal就可以得到释放。
308 static class Entry extends WeakReference> {
309 /** The value associated with this ThreadLocal. */
//强引用
310 Object value;
311
312 Entry(ThreadLocal k, Object v) {
313 super(k);
314 value = v;
315 }
316 }
为什么Entry的value不被设计成弱引用
说到这里，有一个问题我思考了蛮久的，value为啥不搞成弱引用，用完直接扔了多好。最后思考出来得答案(按照源码推了一下)：
不设置为弱引用，是因为不清楚这个Value除了map的引用还是否还存在其他引用，如果不存在其他引用，当GC的时候就会直接将这个Value干掉了，而此时我们的ThreadLocal还处于使用期间（ThreadLocal还有强引用存在着），就会造成Value为null的错误，所以将其设置为强引用。
而为了解决这个强引用的问题，它提供了一种机制就是上面我们说的将Key为Null的Entity直接清除