ThreadLocal全面解析
一、ThreadLocal的介绍1、简介ThreadLocal类用来提供线程内部的局部变量这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文 使用场景及作用
线程并发: 在多线程并发的场景下传递数据: 我们可以通过ThreadLocal在同一线程，不同组件中传递公共变量线程隔离: 每个线程的变量都是独立的，不会互相影响2、基本使用 ThreadLocal的常用方法
方法声明
描述
public class ThreadLocal
创建ThreadLocal对象
public void set(T value)
设置当前线程绑定的局部变量
public T get()
获取当前线程绑定的局部变量
public void remove()
移除当前线程绑定的局部变量
多线程下普通变量与ThreadLocal的代码对比
开启多个线程，每个线程获取自己线程set的值代码语言：javascript代码运行次数：0运行复制public class MyDemo {
// ThreadLocal本地线程变量
private ThreadLocal
// 普通对象变量
private String content;
public static void main(String[] args) {
MyDemo demo = new MyDemo();
for (int i = 0; i < 5; i++) {
Thread thread = new Thread(() -> {
String data = Thread.currentThread().getName() + "的数据";
// 普通变量方式：
demo.content = data;
System.out.print("");
System.out.println("普通变量获取到数据: " + Thread.currentThread().getName() + "--->" + demo.content);
// ThreadLocal方式：
// demo.tl.set(data);
// System.out.print("");
// System.out.println("ThreadLocal获取到数据: " + Thread.currentThread().getName() + "--->" + demo.tl.get());
});
thread.setName("线程" + i);
thread.start();
}
}
}普通变量方式：
多个线程在访问同一个变量的时候出现的异常，线程间的数据没有隔离ThreadLocal方式：
解决了多线程之间数据隔离的问题3、ThreadLocal与synchronized的区别
synchronized
ThreadLocal
原理
同步机制采用以时间换空间的方式, 只提供了一份变量,让不同的线程排队访问
ThreadLocal采用以空间换时间的方式, 为每一个线程都提供了一份变量的副本,从而实现同时访问而相不干扰
侧重点
多个线程之间访问资源的同步
多线程中让每个线程之间的数据相互隔离
二、ThreadLocal的内部结构1、jdk早期设计每个ThreadLocal都创建一个Map然后用线程作为Map的key要存储的局部变量作为Map的value这样就能达到各个线程的局部变量隔离的效果
JDK最早期的ThreadLocal确实是这样设计的，但现在早已不是了
2、JDK8设计Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMapThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）每个线程在往ThreadLocal里放值的时候，都会往自己线程的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离ThreadLocalMap有点类似HashMap的结构，只是HashMap是由数组+链表实现的，而ThreadLocalMap中并没有链表结构ThreadLocalMap中的Entry，它的key是ThreadLocal k ，继承自WeakReference， 也就是我们常说的弱引用类型 ThreadLocal设计改良的好处
这样设计之后每个Map存储的Entry数量就会变少 之前的存储数量由Thread的数量决定（每个Thread作为key）现在是由ThreadLocal的数量决定（ThreadLocal作为线程内map的key）在实际运用当中，往往ThreadLocal的数量要少于Thread的数量当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用3、内存泄露不再会被使用的对象或者变量引用的内存不能被回收，就是内存泄露 为什么要用弱引用？
代码语言：javascript代码运行次数：0运行复制public void function01(){
ThreadLocal tl = new ThreadLocal
tl.set(2021);
tl.get();
}新建了一个ThreadLocal对象，t1是强引用指向ThreadLocal对象调用set()方法后新建一个Entry，通过源码可知Entry对象里的k是弱引用指向ThreadLocal对象当function01方法执行完毕后，栈帧销毁强引用tl也就没有了。但此时线程的ThreadLocalMap里某个entry的key引用还指向这个对象 若这个key引用是强引用，就会导致key指向的ThreadLocal对象及v指向的对象不能被gc回收，造成内存泄漏若这个key引用是弱引用，threadlocal就可以顺利被gc回收，此时Entry中的key=null 在没有手动删除这个Entry以及当前线程依然运行的前提下，也存在有强引用链value不会被回收， 而这块value永远不会被访问到了，导致value内存泄漏在ThreadLocalMap中的set/getEntry方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话，那么是会对value置为null的只要记得在使用完ThreadLocal及时的调用remove，其实就不用走以上步骤了三、ThreadLocal的核心方法源码1、set方法首先获取当前线程，并根据当前线程获取一个Map如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）如果Map为空，则给该线程创建 Map，并设置初始值代码语言：javascript代码运行次数：0运行复制// 设置当前线程对应的ThreadLocal的值
public void set(T value) {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 判断map是否存在
if (map != null){
// 存在则调用map.set设置此实体entry
map.set(this, value);
} else {
// 1）当前线程Thread 不存在ThreadLocalMap对象
// 2）则调用createMap进行ThreadLocalMap对象的初始化
// 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
createMap(t, value);
}
}
/**
* 获取当前线程Thread对应维护的threadLocals
* ThreadLocal.ThreadLocalMap threadLocals = null;
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
// 创建当前线程Thread对应维护的ThreadLocalMap
void createMap(Thread t, T firstValue) {
//这里的this是调用此方法的threadLocal
t.threadLocals = new ThreadLocalMap(this, firstValue);
}2、get方法首先获取当前线程, 根据当前线程获取一个Map如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的Entry的valueMap为空则通过initialValue函数(创建ThreadLocal时重写的方法，不重写则返回空)获取初始值value，然后用ThreadLocal的引用和value创建一个新的Map代码语言：javascript代码运行次数：0运行复制// 返回当前线程中保存ThreadLocal的值
public T get() {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 如果此map存在
if (map != null) {
// 以当前的ThreadLocal 为 key，调用getEntry获取对应的存储实体e
ThreadLocalMap.Entry e = map.getEntry(this);
// 对e进行判空
if (e != null) {
// 获取存储实体 e 对应的 value值
// 即为我们想要的当前线程对应此ThreadLocal的值
T result = (T)e.value;
return result;
}
}
/*
初始化 : 有两种情况有执行当前代码
第一种情况: map不存在，表示此线程没有维护的ThreadLocalMap对象
第二种情况: map存在, 但是没有与当前ThreadLocal关联的entry
*/
return setInitialValue();
}
// 初始化
private T setInitialValue() {
// 调用initialValue获取初始化的值
// 此方法可以被子类重写, 如果不重写默认返回null
T value = initialValue();
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 判断map是否存在
if (map != null){
// 存在则调用map.set设置此实体entry
map.set(this, value);
} else{
// 1）当前线程Thread 不存在ThreadLocalMap对象
// 2）则调用createMap进行ThreadLocalMap对象的初始化
// 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
createMap(t, value);
}
// 返回设置的值value
return value;
}3、initialValue方法在set方法还未调用而先调用了get方法时才执行，并且仅执行1次如果想要一个除null之外的初始值，可以重写此方法，protected方法，只能子类去覆盖代码语言：javascript代码运行次数：0运行复制/**
* 返回当前线程对应的ThreadLocal的初始值
* 此方法的第一次调用发生在，当线程通过get方法访问此线程的ThreadLocal值时
* 除非线程先调用了set方法，在这种情况下，initialValue 才不会被这个线程调用。
* 通常情况下，每个线程最多调用一次这个方法。
*
*
这个方法仅仅简单的返回null {@code null};
* 如果程序员想ThreadLocal线程局部变量有一个除null以外的初始值，
* 必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
* 通常, 可以通过匿名内部类的方式实现
*
* @return 当前ThreadLocal的初始值
*/
protected T initialValue() {
return null;
}示例：
代码语言：javascript代码运行次数：0运行复制private static ThreadLocal
// 重写initialValue方法，设置默认值为false
@Override
protected Boolean initialValue() {
return Boolean.FALSE;
}
};4、withInitial方法JDK8新增，支持Lambda表达式，和ThreadLocal重写的initialValue()效果一样代码语言：javascript代码运行次数：0运行复制public static ThreadLocal withInitial(Supplier supplier) {
return new SuppliedThreadLocal<>(supplier);
}
static final class SuppliedThreadLocal
private final Supplier supplier;
SuppliedThreadLocal(Supplier supplier) {
this.supplier = Objects.requireNonNull(supplier);
}
@Override
protected T initialValue() {
return supplier.get();
}
}示例：
代码语言：javascript代码运行次数：0运行复制@Test
public void jdk8Test(){
// 方式一：
Supplier
@Override
public String get(){
return"supplier_new";
}
};
threadLocal= ThreadLocal.withInitial(supplier);
System.out.println(threadLocal.get());// supplier_new
// 方式二：
threadLocal= ThreadLocal.withInitial(()->"sup_new_2");
System.out.println(threadLocal.get());// sup_new_2
}5、remove方法首先获取当前线程，并根据当前线程获取一个Map如果获取的Map不为空，则移除当前ThreadLocal对象对应的entry代码语言：javascript代码运行次数：0运行复制// 删除当前线程中保存的ThreadLocal对应的实体entry
public void remove() {
// 获取当前线程对象中维护的ThreadLocalMap对象
ThreadLocalMap m = getMap(Thread.currentThread());
// 如果此map存在
if (m != null){
// 存在则调用map.remove
// 以当前ThreadLocal为key删除对应的实体entry
m.remove(this);
}
}6、子类InheritableThreadLocal类使用ThreadLocal的时候，在异步场景下是无法给子线程共享父线程中创建的线程副本数据的为了解决这个问题，JDK中还有一个InheritableThreadLocal类代码语言：javascript代码运行次数：0运行复制public class InheritableThreadLocalDemo {
public static void main(String[] args) {
ThreadLocal
ThreadLocal
threadLocal.set("父类数据:threadLocal");
inheritableThreadLocal.set("父类数据:inheritableThreadLocal");
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("子线程获取父类ThreadLocal数据：" + threadLocal.get());
System.out.println("子线程获取父类inheritableThreadLocal数据：" + inheritableThreadLocal.get());
}
}).start();
}
}输出结果：
代码语言：javascript代码运行次数：0运行复制子线程获取父类ThreadLocal数据：null
子线程获取父类inheritableThreadLocal数据：父类数据:inheritableThreadLocal 实现原理
InheritableThreadLocal类是ThreadLocal类的子类ThreadLocal中每个线程拥有它自己的值，与ThreadLocal不同的是，InheritableThreadLocal允许一个线程以及该线程创建的所有子线程都可以访问它保存的值代码语言：javascript代码运行次数：0运行复制public class InheritableThreadLocal
protected T childValue(T parentValue) {
return parentValue;
}
// 直接获取Thread类中的map
ThreadLocalMap getMap(Thread t) {
return t.inheritableThreadLocals;
}
// 创建map，赋值inheritableThreadLocals
void createMap(Thread t, T firstValue) {
t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
}
}线程类中维护了两个Map threadLocals：每个线程自己私有的inheritableThreadLocals：本线程以及自己创建的子线程共享的实现原理是子线程是通过在父线程中通过调用new Thread()方法来创建子线程Thread#init方法在Thread的构造方法中被调用在init方法中拷贝父线程数据到子线程中代码语言：javascript代码运行次数：0运行复制private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
...
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
...
}但InheritableThreadLocal仍然有缺陷，一般我们做异步化处理都是使用的线程池而InheritableThreadLocal是在new Thread中的init()方法给赋值的，所以线程池复用则会出现问题阿里巴巴开源了一个TransmittableThreadLocal组件就可以解决这个问题四、ThreadLocalMap源码分析1、Hash算法ThreadLocalMap是Map结构，当然也要实现自己的hash算法来解决散列表数组冲突问题代码语言：javascript代码运行次数：0运行复制int i = key.threadLocalHashCode & (len-1);ThreadLocalMap中hash算法很简单，这里i就是当前key在散列表中对应的数组下标位置计算坐标key：任何数 & (table.length-1)的结果也一定在[0, table.length-1]范围，而且&的运算效率高创建Entry对象，key为ThreadLocal对象(弱引用)，value为设置的值默认Entry数组容量为16，threshold阈值为容量的2/3也就是10，数组table内存在的对象数量size超过10，就会扩容代码语言：javascript代码运行次数：0运行复制public class ThreadLocal
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);
}
// 默认
private static final int INITIAL_CAPACITY = 16;
static class ThreadLocalMap {
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
// 默认创建容量为16的Entry数组
table = new Entry[INITIAL_CAPACITY];
// 任何数 & (table.length-1)的结果也一定在[0, table.length-1]范围，而且&的运算效率高
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 创建Entry对象，key为ThreadLocal对象(弱引用)，value为设置的值
table[i] = new Entry(firstKey, firstValue);
size = 1;
// 设置数组容量阈值
setThreshold(INITIAL_CAPACITY);
}
// 默认容量为16，threshold阈值为10，数组table内存在的对象数量size超过10，就会扩容
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
}
}每当创建一个ThreadLocal对象，这个ThreadLocal.nextHashCode这个值就会增长 0x61c88647，这个值很特殊，它是斐波那契数也叫黄金分割数hash增量为这个数字，带来的好处就是hash分布非常均匀测试：数据会平均散落到所有位置上
2、Hash冲突虽然ThreadLocalMap中使用了黄金分割数来作为hash计算因子，大大减少了Hash冲突的概率，但是仍然会存在冲突如果冲突了，就会通过nextIndex方法再次计算哈希值，线性探测法（不断加1）代码语言：javascript代码运行次数：0运行复制private void set(ThreadLocal key, Object value) {
ThreadLocal.ThreadLocalMap.Entry[] tab = table;
int len = tab.length;
//计算索引(重点代码，刚才分析过了）
int i = key.threadLocalHashCode & (len-1);
/**
* 使用线性探测法查找元素（重点代码）
*/
for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal k = e.get();
//ThreadLocal 对应的 key 存在，直接覆盖之前的值
if (k == key) {
e.value = value;
return;
}
// key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，
// 当前数组中的 Entry 是一个陈旧（stale）的元素
if (k == null) {
//用新元素替换陈旧的元素，这个方法进行了不少的垃圾清理动作，防止内存泄漏
replaceStaleEntry(key, value, i);
return;
}
}
//ThreadLocal对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry。
tab[i] = new Entry(key, value);
int sz = ++size;
/**
* cleanSomeSlots用于清除那些e.get()==null的元素，
* 这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置null。
* 如果没有清除任何entry,并且当前使用量达到了负载因子所定义(长度的2/3)，那么进行
* rehash（执行一次全表的扫描清理工作）
*/
if (!cleanSomeSlots(i, sz) && sz >= threshold)
// 这里table会扩容
rehash();
}
/**
* 获取数组的下一个索引
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}首先还是根据key计算出索引 i，然后查找i位置上的Entry若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry不断循环检测，直到遇到Entry为null的地方，如果没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1总结ThreadLocal并不解决线程间共享数据的问题ThreadLocal适用于变量在线程间隔离且在方法间共享的场景ThreadLocal通过隐式的在不同线程内创建独立实例副本避免了实例线程安全的问题每个线程持有一个只属于自己的专属Map并维护了ThreadLocal对象与具体实例的映射，该Map由于只被持有它的线程访问，故不存在线程安全以及锁的问题ThreadLocalMap的Entry对ThreadLocal的引用头弱引用，避免了ThreadLocal对象无法被回收的问题者会通过expungeStaleEntry,cleanSomeSlots,replaceStaleEntry这三个方法回收键头为null的Entry