当前位置：网站首页>ThreadLocal详细分析
ThreadLocal详细分析
2022-08-04 10:07:00 【勇敢小姚】
目录
一、ThreadLocal简介
1、介绍
多线程访问同一个共享变量的时候容易出现并发问题，因此为了保证线程安全性，我们都会采用加锁的方式。而ThreadLocal是除加锁方式之外的另一种保证线程安全性的方法。 ThreadLocal通过每个线程保存一份资源的副本，且这个副本只能被当前线程访问。这样的话每个线程都拥有一份，那么自然而然也就不需要对资源竞争了。
在JDK8之前，每个ThreadLocal都创建一个ThreadLocalMap，用线程作为ThreadLocalMap的key，要存储的局部变量作为ThreadLocalMap的value，这样就实现了各个线程的局部变量的隔离作用。
而在JDK8之后，每个线程维护一个ThreadLocalMap，这个ThreadLocalMap的key是ThreadLocal实例本身，value才是真正要存储的变量副本。线程内部的Map由ThreadLocal维护，由ThreadLocal负责向map获取和设置线程的变量值。对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。
好处：
- 减少ThreadLocalMap存储的Entry数量：因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。在实际运用当中，往往ThreadLocal的数量要少于Thread的数量
- 当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用（但是不能避免内存泄漏问题，解决内存泄漏问题应该在使用完后及时调用remove()对ThreadMap里的Entry对象进行移除，由于Entry继承了弱引用类，会在下次GC时被JVM回收）
2、常用方法
在ThreadLocal类中，有以下几个比较常用的方法：
- get：用于获取 ThreadLocal 在当前线程中保存的变量副本。
- set：用于设置当前线程中变量的副本。
- remove：用于删除当前线程中变量的副本。如果此线程局部变量随后被当前线程读取，则其值将通过调用其 initialValue 方法重新初始化，除非其值由中间线程中的当前线程设置。 这可能会导致当前线程中多次调用 initialValue 方法。
- initialValue：为 ThreadLocal 设置默认的 get 初始值，需要重写 initialValue 方法 。
3、案例
public class TestThreadLocal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public static void main(String[] args) {
TestThreadLocal testThreadLocal = new TestThreadLocal();
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
testThreadLocal.setName(Thread.currentThread().getName() + "的信息");
System.out.println(Thread.currentThread().getName() + ": " + testThreadLocal.getName());
}
}).start();
}
}
}执行结果：
从结果可以看出多个线程在访问同一个变量的时候出现的异常，线程间的数据没有隔离。下面我们来看下采用 ThreadLocal 的方式来解决这个问题的例子。
public class TestThreadLocal {
private static ThreadLocal<String> t = new ThreadLocal<>();
private String name;
public String getName() {
return t.get();
}
public void setName(String name) {
t.set(name);
}
public static void main(String[] args) {
TestThreadLocal testThreadLocal = new TestThreadLocal();
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
testThreadLocal.setName(Thread.currentThread().getName() + "的信息");
System.out.println(Thread.currentThread().getName() + ": " + testThreadLocal.getName());
}
}).start();
}
}
}
执行结果：
二、ThreadLocal原理分析
1、ThreadLocal的存储结构
在Thread类中维护着ThreadLocal.ThreadLocalMap类型的成员threadLocals，这个成员用来存储当前线程独占的变量副本。ThreadLocalMap是ThreadLocal的静态内部类，它维护者一个Entry数组，用来存储键值对。
public class Thread implements Runnable {
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
}
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
}可以看到：Entry的key是ThreadLocal对象，value则是传递进行的对象，即变量副本，且Entry继承了WeakReference。
2、set(T value)方法源码
源码如下：
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//获取threalLocals
ThreadLocalMap map = getMap(t);
//将ThreadLocal和值一起存入当前线程的ThreadLocalMap中
if (map != null)
//如果存在就调用map.set()，这里的this指的是调用此方法的ThreadLocal对象
map.set(this, value);
else
createMap(t, value);
}
//获取当前线程维护的ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
//创建当前线程
void createMap(Thread t, T firstValue) {
//这里的this是调用此方法的threadLocal
t.threadLocals = new ThreadLocalMap(this, firstValue);
}在ThreadLocal的set方法中，首先获取当前线程，然后调用getMap(Thread t)获取当前线程中ThreaLocalMap类型的threadLocals字段。然后将ThreadLocal一块放入到当前线程的ThreadLocalMap中。如果获取到的Map不为空，则将参数设置到Map中，否则就创建Map，并设置初值。
3、get()方法
源码如下：
public T get() {
//获取当前线程
Thread t = Thread.currentThread();
//拿到threadLocals字段
ThreadLocalMap map = getMap(t);
//如果map存在
if (map != null) {
//获取对应的存储实体
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
//获取存储尸体对应的value值
T result = (T)e.value;
return result;
}
}
//执行当前代码的两种情况：1、map不存在，说明此线程没有ThreadLocalMap对象；2、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;
}执行流程：先获取到当前线程，并根据当前线程获取一个Map。如果获取的map不为空，则在Map中以ThreadLocal的引用作为key在map中获取对应的Entry。如果entry不为空则返回e.value；如果e为空或者Map为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map。
4、remove()方法
源码如下：
public void remove() {
// 获取当前线程对象中维护的ThreadLocalMap对象
ThreadLocalMap m = getMap(Thread.currentThread());
// 如果此map存在
if (m != null)
// 存在则调用map.remove
// 以当前ThreadLocal为key删除对应的实体entry
m.remove(this);
}
执行流程：首先获取当前线程，并根据当前线程获取一个Map。如果获取的map不为空，则移除当前ThreadLocal对象对应的Entry。
5、initialValue()方法
源码如下：
/**
* 返回当前线程对应的ThreadLocal的初始值
* 此方法的第一次调用发生在，当线程通过get方法访问此线程的ThreadLocal值时
* 除非线程先调用了set方法，在这种情况下，initialValue 才不会被这个线程调用。
* 通常情况下，每个线程最多调用一次这个方法。
*
* <p>这个方法仅仅简单的返回null {@code null};
* 如果想ThreadLocal线程局部变量有一个除null以外的初始值，
* 必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
* 通常, 可以通过匿名内部类的方式实现
*
* @return 当前ThreadLocal的初始值
*/
protected T initialValue() {
return null;
}
该方法作用是返回该线程局部变量的初始值。从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次，这个方法缺省实现直接返回一个null。如果想要一个除null之外的初始值，可以重写此方法。（备注： 该方法是一个protected的方法，显然是为了让子类覆盖而设计的）
6、如何解决hash冲突问题
从前面可以看到ThreadLocalMap是类似于Map的数据结构，但是它并没有实现Map接口，那么它也就不支持Map接口中的next方法。因此可以推断出：ThreadLocalMap并不是通过拉链法来解决hash冲突问题的。实际上，ThreadLocalMap是使用线性探测的方式来解决hash冲突的，即：根据初始key的hashcode值来确定元素在table数组中的位置，如果这个位置已经被其他的key占据，那么就通过算法寻找下一个位置，直到找到能够存放的位置为止。
在前面查看set()方法源码的时候，当map为空时调用了cerateMap()方法，而该方法中调用了有参构造：ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)
/*
* firstKey : 本ThreadLocal实例(this)
* firstValue ： 要保存的线程本地变量
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//初始化table
table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
//计算索引(重点代码）
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//设置值
table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
size = 1;
//设置阈值
setThreshold(INITIAL_CAPACITY);
}
构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并设置size和threshold。
重点看一下计算索引这一块：
private final int threadLocalHashCode = nextHashCode();
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
//AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减,适合高并发情况下的使用
private static AtomicInteger nextHashCode = new AtomicInteger();
//特殊的hash值
private static final int HASH_INCREMENT = 0x61c88647;
这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_INCREMENT，HASH_INCREMENT = 0x61c88647,这个值跟斐波那契数列（黄金分割数）有关，其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里, 也就是Entry[] table中，这样做可以尽量避免hash冲突。
关于& (INITIAL_CAPACITY - 1)
计算hash的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现。正是因为这种算法，我们要求size必须是2的整次幂，这也能保证在索引不越界的前提下，使得hash发生冲突的次数减小。
来看下ThreadLocalMap中的set方法：
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)
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
- 不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1
- 最后调用cleanSomeSlots，清理key为null的Entry，最后返回是否清理了Entry，接下来再判断sz 是否>= thresgold达到了rehash的条件，达到的话就会调用rehash函数执行一次全表的扫描清理
三、ThreadLocalMap的内存泄漏问题
在前面我们看到了，ThreadLocalMap的Entry继承了WeakReference，其中key是弱引用，而value是强引用。如果ThreadLocal对象没有外部强引用来引用它，那么ThreadLocal对象会在下次GC时候被回收。此时，如果Entry中的key已经被回收，但是value又是强引用，并不会被垃圾收集器回收。如果创建ThreadLocal的线程一直持续运行，那么value就会一直得不到回收，从而产生内存泄漏。
在Java中有四种引用类型，这里介绍一下强引用和弱引用：
- 强引用（“Strong” Reference），就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾回收器就不会回收这种对象。
- 弱引用（WeakReference），垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。
1、如果key使用强引用
如下图：
假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。但是因为threadLocalMap的Entry强引用了threadLocal，造成threadLocal无法被回收。在没有手动删除这个Entry以及CurrentThread依然运行的前提下，始终有强引用链 threadRef->currentThread->threadLocalMap->entry，Entry就不会被回收（Entry中包括了ThreadLocal实例和value），导致Entry内存泄漏。 也就是说，ThreadLocalMap中的key使用了强引用， 是无法完全避免内存泄漏的。
2、如果key使用了弱引用
如下图：
假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收，此时Entry中的key=null。但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下，也存在有强引用链 threadRef->currentThread->threadLocalMap->entry -> value ，value不会被回收， 而这块value永远不会被访问到了，导致value内存泄漏。 也就是说，ThreadLocalMap中的key使用了弱引用， 也有可能内存泄漏。
既然弱引用和强引用都无法阻止内存泄漏的问题，那么为啥还要选择弱引用？
根据刚才的分析, 我们知道了： 无论ThreadLocalMap中的key使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系。
要避免内存泄漏有两种方式：
- 使用完ThreadLocal，调用其remove方法删除对应的Entry
- 使用完ThreadLocal，当前Thread也随之运行结束
相对第一种方式，第二种方式显然更不好控制，特别是使用线程池的时候，线程结束是不会销毁的。也就是说，只要记得在使用完ThreadLocal及时的调用remove，无论key是强引用还是弱引用都不会有问题。那么为什么key要用弱引用呢？
事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话，那么是会对value置为null的。这就意味着使用完ThreadLocal，CurrentThread依然运行的前提下，就算忘记调用remove方法，弱引用比强引用可以多一层保障：弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用set,get,remove中的任一方法的时候会被清除，从而避免内存泄漏。
解决办法：使用ThreadLocal的set方法，显式调用remove方法。
ThreadLocal<String> threadLocal = new ThreadLocal();
try {
threadLocal.set("xxx");
// ...
} finally {
threadLocal.remove();
}
四、总结
- threadLocal操作的是每个线程自己的ThreadLocalMap，因此不会有线程的竞争。key是当前的threadlocal对象，value是当前线程放在这个threadlocal里面的值。
- ThreadLocalMap是基于开放定址法（线性探测再散列）实现的hash表，这里没有采用HashMap的数组加链表的实现方式是因为这里的场景决定了hash表中不会有太多的值，通过采用独特的斐波那契散列求hash值，可以极大的降低hash冲突概率，访问数据速度也比HashMap快。
- ThreadLocalMap的实现类似WeakHashMap实现，都通过WeakReference封装了key值，防止内存泄漏；
- ThreadLocalMap实现的挺复杂的，主要是为了避免内存泄露，加了好多处理过期数据的操作，这就在线程中添加了多余的操作。所以如果确定ThreadLocal没有用的话，可以调用ThreadLocal的remove()方法，这样就避免了在ThreadLocalMap中查找过期数据并处理的操作。
边栏推荐
- HTB-Nibbles
- 超宽带UWB实时精准定位，短距离无缝交互应用，物联网厘米级精度方案
- KubeDNS 和 CoreDNS
- MySQL：面试问的范式设计
- LeetCode简单题之最好的扑克手牌
- XCTF-easy_Maze
- Cloud function to achieve automatic website check-in configuration details [Web function/Nodejs/cookie]
- Introduction to the core methods of the CompletableFuture interface
- leetcode二叉树系列(一）
- 2022-08-03 第六小组 瞒春 学习笔记
猜你喜欢
![[论文阅读] Unpaired Image-to-Image Translation Using Adversarial Consistency Loss](/img/4d/9c2f94f475834771f6ad6ffe8f8b35.png)
随机推荐
ps抠图怎么抠出来，自学ps软件photoshop2022，ps怎么抠出想要的部分-笔记记录
canvas画图时的bug记录
leetcode经典例题——56.合并区间
rk3399-339 usb设备复合 总体流程
MySQL：面试问的范式设计
无代码平台多项选择入门教程
MindSpore:MindSpore GPU版本安装问题
IDEA启动热部署
什么是元宇宙？
广东对小鹏/广汽丰田开展网络安全检查
iMeta | Baidu certification is completed, search "iMeta" directly to the publisher's homepage and submission link
双重for循环案例以及while循环和do while循环案例
Detailed explanation of NAT/NAPT address translation (internal and external network communication) technology [Huawei eNSP]
leetcode单调栈经典例题——最大矩形
【c】操作符详解（二）
Qt：小的任务管理器（task）
【C补充】指向指针或函数的指针
LeetCode简单题之最好的扑克手牌
leetcode二叉树系列(二叉搜索树篇)
DOM简述