文章目录
- ThreadLocal原理
- 大致设计
- 底层理解
- 【Java面试】说说你对ThreadLocal内存泄漏问题的理解
- hash冲突的解决
- get/set/remove方法的一些细节
在多线程情况下，对于一个共享变量或者资源对象进行读或者写操作时，就必须考虑线程安全问题。而ThreadLocal采用的是完全相反的方式来解决线程安全问题。他实现了对资源对象的线程隔离，让每个线程各自使用各自的资源对象，避免争用引发的线程安全问题。 ThreadLocal同时实现了线程内的资源共享。 例如方法1对ThreadLocal中的变量进行了设置，那么方法2中只要是同一个线程，那么他也能访问到线程1在ThreadLocal中设置的变量。
ThreadLocal原理
package com.example.scheduledlovetoobject.threadPoolTest;
import lombok.SneakyThrows;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
* @author: Zhangjinbiao
* @Date: 2022/12/7 10:33
* @Connection: qq460219753 wx15377920718
* Description:
* Version: 1.0.0
*/
public class ThreadLocalTest {
public static void main(String[] args) {
test1();
test2();
}
public static void test1() {
for (int i = 0; i < 5; i++) {
new Thread(() -> {
System.out.println(Utils.getConnection());
}, "t" + i).start();
}
}
public static void test2() {
for (int i = 0; i < 2; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + Utils.getConnection());
System.out.println(Thread.currentThread().getName() + Utils.getConnection());
System.out.println(Thread.currentThread().getName() + Utils.getConnection());
}, "t" + i).start();
}
}
static class Utils {
public static final ThreadLocal<Connection> tl = new ThreadLocal<>();
public static Connection getConnection() {
Connection conn = tl.get();
if (conn == null) {
conn = innerGetConnection();
tl.set(conn);
}
return conn;
}
private static Connection innerGetConnection() {
try {
return DriverManager.getConnection("jdbc:mysql://localhost:3306/yoshino?useSSL=false", "root", "root");
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
}
大致设计
上面的代码很容易就看懂了，问题在于，ThreadLocal是怎么做到不同的线程存放不同的对象，而同一个线程能取出同样的对象的呢？
其实当你看到它使用的是set和get方法的时候，你就应该大致能猜到，他的底层应该有一个Map结构来存储线程以及这个线程中的资源，当然，这是JDK早期的设计了，下面是早期的设计
在JDK8中，ThreadLocal的结构已经改变了。
可以发现，我们并不是在ThreadLocal中存储我们的资源，而是在每一个线程中存储，由于每一个线程对象都有一个ThreadLocalMap的局部变量，因此每一个线程之间的ThreadLocalMap都是互相隔离的，所以同一个线程能访问到同一个ThreadLocalMap对象中的数据。我们使用ThreadLocal的set方法的时候其实是向Thread中的ThreadLocalMap设置值。那么下次我们调用ThreadLocal的get方法的时候，他其实会先获取当前线程对象，然后使用这个线程对象去访问ThreadLocalMap中的数据。
只有在你第一次使用这个Map集合的时候，他才会创建，也就是它使用的是懒加载。
因此ThreadLocal的原理是， 每一个线程对象中都有一个ThreadLocalMap类型的成员变量，用来存储资源对象。这个Map的key是ThreadLocal对象，value才是真正要存储的资源。
具体的过程是这样的:
( 1 ) 每个Thread线程内部都有一个Map (ThreadLocalMap)
( 2 ) Map里面存储ThreadLocal对象( key )和线程的变量副本 ( value )
( 3 ) Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。
( 4 )对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。
那么现在的设计的好处在哪里呢？
- 每个Map存储的Entry变少，在早期的设计中key为Thread对象，而我们知道Thread对象的个数是很多的，而现在的设计key为ThreadLocal，我们一般设定ThreadLocal为static，所以能保证ThreadLocalMap存储的键值对更少。
- 现在在Thread销毁之后，ThreadLocalMap也会自动销毁，减少对内存的时候。而早期的设计，即使线程消失了，ThreadLocalMap依旧存在，还是要维护它。
方法介绍
- 调用set方法，就是以ThreadLocal自己作为key，资源对象作为value，放入当前线程的ThreadLocalMap集合中
- 调用get方法，就是以ThreadLocal自己作为key，到当前线程中查找关联的资源值
- 调用remove方法，就是以ThreadLocal自己作为key，移除当前线程关联的资源值
set方法
执行流程：
首先获取当前线程，并根据当前线程获取一个Map
如果获取的Map不为空，则将次数设置到Map中
如果Map为空，则给该线程创建Map，并设置初始值
public void set(T value) {
//获取当前线程对象
Thread t = Thread.currentThread();
//获取此线程对象中的Map对象
ThreadLocalMap map = getMap(t);
if (map != null) {
//已经创建那么直接放入此entry
map.set(this, value);
} else {
//不存在则创建 并将当前线程t和value值作为第一个entry存放到Map中
createMap(t, value);
}
}
//返回当前线程对应的Map
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
//这里的this是调用createMap的ThreadLocal对象
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
get方法
执行流程：
A.首先获取当前线程，根据当前线程获取一个Map
B.如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的Entry e，否则转到D
C.如果e不为null，则返回e.value，否则转到D
D.Map为空或者e为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map
总结:先获取当前线程的ThreadLocalMap变量，如果存在则返回值，不存在则创建并返回初始值。
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
//以当前ThreadLocal为key，调用getEntry获取对应的存储实体e
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//初始化，有两种情况会执行这个代码
//map不存在，表示此线程没有维护ThreadLocalMap对象
//map存在，但是没有查询到与当前ThreadLocal关联的entry
return setInitialValue();
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
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);
}
private T setInitialValue() {
//调用initialValue获取初始化的值
//子类可以重写，不重写返回null
T value = initialValue();
//获取当前线程对象
Thread t = Thread.currentThread();
//获取当前线程对象维护的Map
ThreadLocalMap map = getMap(t);
if (map != null) { //map存在设置实体entry
map.set(this, value);
} else {
//1：当前线程不存在ThreadLocalMap对象
//2：则调用这个方法创建Map
//并且将t和value设置进去
createMap(t, value);
}
if (this instanceof TerminatingThreadLocal) {
TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
}
return value;
}
remove方法
执行流程：
首先获取当前线程，并且根据该线程获取一个Map
如果获取的Map不为空，则移除当前ThreadLocal对象对应的entry
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null) {
m.remove(this);
}
}
initialValue方法
( 1 ）这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次。
( 2 )这个方法缺省实现直接返回一个null。
( 3 )如果想要一个除null之外的初始值，可以重写此方法。(备注∶该方法是一个protected的方法显然是为了让子类覆盖而设计的)
返回当前线程对应的ThreadLocal的初始值
此方法的第一次调用发生在，当线程通过get方法访问此钱程的
ThreadLocal值时除非线程先调用了set方法，在这种情况下，
initialvalue 才不会被这个线程调用。通常情况下，每个线程最多调用一次这个方法。
这个方法仅仅简单的返回nu1l {@code nu11};
如果程序员想ThreadLoca1线程局部变量有一个除nu11以外的初始值，
必须通过子类继承{@code ThreadLocaT]的方式去重写此方法
通常,可以通过匿名内部类的方式实现
protected T initialValue() {
return null;
}
底层理解
ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map功能，其内部的Entry也是独立实现的。
在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。不过Entry中的key只能是ThreadLocal对象，这点在构造方法中已经限定死了。|
另外，Entry继承WeakReference，也就是key ( ThreadLocal）是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
//这里要注意的是它的entey的key必须是ThreadLocal
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// 容量必须是2的n次幂
private static final int INITIAL_CAPACITY = 16;
//存放键值对的数组
private Entry[] table;
//table中元素个数
private int size = 0;
//扩容阈值
private int threshold; // Default to 0
}
下面是我对ThreadLocal的理解的结构图
首先我们知道，你使用ThreadLocal的时候，它的实例对象只有一个无参的get方法，也就是说你不能使用传统的Map结构去根据key获取value，而上面的ThreadLocalMap中的Entry结构也已经说明了，你使用那个ThreadLocal对象去调用这个get方法，那你就是获取那个ThreadLocal在某个Thread中的ThreadLocalMap中对应的value值。
如果你整个项目中只有一个ThreadLocal，但是有多个线程，那么这个ThreadLocal其实就是在不同的Thread中的ThreadLocalMap的key而已。
也就是其实ThreadLocal：Thread：ThreadLocalMap的关系为1：n：n，所以能做到在不同线程调用ThreadLocal对象的get或者set方法的时候，是对不同的Thread中的ThreadLocalMap对象获取和设置值。
如果还不理解，那么用下面的代码理解一下：
static class T {
public ThreadLocal<Object> tl1 = new ThreadLocal<>();
public ThreadLocal<Object> tl2 = new ThreadLocal<>();
}
public static void test3() {
T t = new T();
new Thread(()->{
t.tl1.set("t1线程设置的tl1");
t.tl2.set("t1线程设置的tl2");
System.out.println(t.tl1.get());
System.out.println(t.tl2.get());
},"t1").start();
new Thread(()->{
t.tl1.set("t2线程设置的tl1");
t.tl2.set("t2线程设置的tl2");
System.out.println(t.tl1.get());
System.out.println(t.tl2.get());
},"t2").start();
}
可以发现我在同一个线程中使用了多个ThreadLocal，但是即使是同一个线程，使用不同的ThreadLocal去去获取数据，得到的数据也是不同的。这也就是因为对于同一个Thread，他其实只有一个Map，但是这个Map的结构要求他的key必须是ThreadLocal类型，而值随意。因此你能做到如果使用不同的ThreadLocal作为key，那么就能取得不同的值。此时我们就可以得到下面的图：
而如果我们使用不同的ThreadLocal作为key，那么他们也是通过hash方法来找到对应的数组下标的。
因此，我们使用线程池的时候，按照上面的原理，由于这些线程被复用，所以如果我们在使用线程池中的线程的时候，如果这个对象中的ThreadLocalMap没有被清理，就可能导致我们会得到上一次的值，也就是"前世"。所以我们在使用ThreadLocal的时候要求使用完毕应该调用remove方法来清空ThreadLocalMap中的数据。当然，我们也可以利用线程池的这一点，来减少我们new对象的次数，来复用这些对象。
【Java面试】说说你对ThreadLocal内存泄漏问题的理解
hash冲突的解决
hash冲突的解决是Map中的一个重要内容。
而ThreadLocal也是使用了Map结构，因此也需要解决hash冲突。
首先看一下ThreadLocalMap的构造函数
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
//获取hash值
private final int threadLocalHashCode = nextHashCode();
//原子类
private static AtomicInteger nextHashCode =
new AtomicInteger();
//hash值增量
private static final int HASH_INCREMENT = 0x61c88647;
//返回下一个hash值
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
构造函数首先创建了一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并且设置size和thresholad。
这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_INCREMENT， HASH_INCREMENT等于0x61c88647，这个值跟斐波那契数列（黄金分割数）有关，其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里，也就是Entry[] table中，这样做可以尽量避免hash冲突。
关于 & (INITIAL_CAPACITY - 1)
计算hash的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现。正是因为这种算法，我们要求size必须是2的整次幂，这也能保证保证在索引不越界的前提下，使得hash发生冲突的次数减小。
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
//计算索引
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//如果已经有这个key则直接覆盖
if (k == key) {
e.value = value;
return;
}
//key为null，但是值补位null，说明ThreadLocal对象已经被回收了
//当前数组中的Entry是一个陈旧的stale元素
if (k == null) {
//用新元素替换旧的，这个方法做了很多垃圾回收操作，防止内存泄漏
replaceStaleEntry(key, value, i);
return;
}
}
//key不存在且没有旧元素，直接在空元素位置创建一个新的Entry
tab[i] = new Entry(key, value);
int sz = ++size;
//cleanSomeSlots用于清除e.get()==null的元素
//这种数据key关联的对象已经被回收，所以此时可以把对应的位置设置为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);
}
代码执行流程：
A.首先还是根据key计算出索引 i ，然后查找 i 位置上的Entry ,
B.若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值，
C.若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry,
D.不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1。
最后调用cleanSomeSlots，清理key为null的Entry，最后返回是否清理了Entry，接下来再判断sz是否>=threshold达到了rehash的条件，达到的话就会调用rehash函数执行一次全表的扫描清理。
重点分析:
ThreadLocalMap使用线性探测法来解决哈希冲突的。
该方法一次探测下一地址，直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出。
举个例子，假设当前table长度为16，也就是说如果计算出来key的hash值为14，如果table[14]上已经有值，并且其key与当前key不一致，那么就发生了hash冲突，这个时候将14加1得到15，取table[15]进行判断，这个时候如果还是冲突会回到0，取table[0]，以此类推，直到可以插入。
按照上面的描述,可以把Entry[] table看成一个环形数组。
get/set/remove方法的一些细节
对于get方法，如果get的时候发现key是null，也就是此时ThreadLocal已经被回收了，那么此时就会把对应的value也设定为空来释放空间，但是会把key再次设定为当前ThreadLocal。
对于set方法，如果发现set的时候得到的索引处的key为null，那么说明已经被回收掉了，那么此时会把数据放入进去，然后使用一种启发式扫描，他会扫描邻近的key是否为null，如果为null就进行对value的清理。相比全表扫描效率更高。启发次数与元素个数，是否发现null key有关。
对于get和set方法，他们只有在没有引用key（null key）的时候才会触发垃圾回收。 但是我们使用ThreadLocal一般都是静态的，所以这个ThreadLocal一般不会被回收，也就是他是一个强引用，所以一般不会出现null key的情况。
因此一般我们都使用remove方法，在某一个key不使用的时候，手动使用remove方法来设定其为null。
![[附源码]计算机毕业设计酒店在线预约咨询小程序Springboot程序](https://img-blog.csdnimg.cn/4f18829975f243d0945cefb5fd84fc3d.png)
![[附源码]Python计算机毕业设计Django行程规划app](https://img-blog.csdnimg.cn/ea06d50398254333bba84a285aaf7263.png)
