当前位置：首页 > news >正文

ThreadLocal原理、结构、源码解析

news 2026/2/7 12:34:23

文章目录

- 一、Thread简介
- - 1.什么是ThreadLocal
  - 2.为什么要是用ThreadLocal
  - - 2.1Synchronized、Lock保证线程安全
    - 2.2ThreadLocal保证线程安全
  - 3.ThreadLocal和Synchronized的区别
- 二、ThreadLocal原理
- - 1.Thread抽象内部结构
  - 2.ThreadLocal源码
  - - 2.1Thread、ThreadLocal、ThreadLocalMap、Entry之间关系
    - 2.2ThreadLocal类的set()方法
    - 2.3ThreadLocal类的get()方法
    - 2.4ThreadLocal类的remove()方法
    - 2.5面试：说一说ThreadLocal原理、Thread如何实现线程隔离的
- 三、深究ThreadLocal
- - 1.为什么不直接用线程id作为ThreadLocalMap的key呢？
  - 2.ThreadLocal导致内存泄漏的原因
  - 3.ThreadLocalMap在设计中有没有考虑到内存泄漏这点呢？
  - 4.在使用ThreadLocal中，我们应该注意什么
  - 5.key是弱引用，GC回收会影响ThreadLocal的正常工作嘛
  - 6.Entry的key为什么要设计成弱引用呢，为什么不使用强引用
  - - 6.1Entry的key如果使用强引用
    - 6.2为什么要设计成弱引用
    - 6.3四种引用类型
  - 7.我们希望父子线程之间共享数据，应该怎么做呢
  - - 7.1InheritableThreadLocal
    - 7.2InheritableThreadLocal是如何实现父子线程之间共享的

一、Thread简介

1.什么是ThreadLocal

ThreadLocal，即线程本地变量。如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地拷贝，多个线程操作这个变量的时候，实际是在操作自己本地内存里面的变量，从而起到线程隔离的作用，保证了线程安全。

因为每个 Thread 内有自己的实例副本，且该副本只能由当前 Thread 使用。这是也是 ThreadLocal 命名的由来。
每个 Thread 有自己的实例副本，且其它 Thread 不可访问，那就不存在多线程间共享的问题。

2.为什么要是用ThreadLocal

保证线程安全，并发场景下，会出现多个线程共享一个变量的场景，这种场景可能会出现线程安全性问题，我们可以采取加锁的方式(Synchronized、Lock)方式，也可以使用使用ThreadLocal方式来避免线程安全问题。

2.1Synchronized、Lock保证线程安全

采用加锁方式保证线程安全到导致系统变慢。共享变量某个时刻只能由一个线程访问，其他线程需要等到该线程释放锁才能访问，影响系统性能。

2.2ThreadLocal保证线程安全

使用ThreadLocal。使用ThreadLocal类访问共享变量时，会在每个线程的本地，都保存一份共享变量的拷贝副本。多线程对共享变量修改时，实际上操作的是这个变量副本，从而保证线性安全。

3.ThreadLocal和Synchronized的区别

ThreadLocal和Synchronized都是为了解决并发问题。
Synchronized用于线程共享，而ThreadLocal用于线程隔离。
Synchronized是时间换空间，ThreadLocal是空间换时间。
Synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。

二、ThreadLocal原理

1.Thread抽象内部结构

简单理解（看不懂先往下看再回顾）：

Thread类中有ThreadLocal.ThreadLocalMap threadLocals属性
ThreadLocalMap 是Thread的静态内部类，它维护着Entry对象数组，每个Entry代表一个ThreadLocalMap对象
Entry是ThreadLocalMap的静态内部类，存储采用的是k-v形式，key为ThreadLocal，value为我

2.ThreadLocal源码

2.1Thread、ThreadLocal、ThreadLocalMap、Entry之间关系

先根据源码砍砍他们之间的关系

Thread的成员变量ThreadLocal.ThreadLocalMap
ThreadLocal.ThreadLocalMap是ThreadLocal的静态内部类
Entry是ThreadLocalMap的静态内部类，Entry继承了弱引用，也就是说，如果外部没有强引用关联的话，下一次GC时会被回收。
在Entry是一个k-v形式，内部使用ThreadLocal作为key，使用我们设置的value作为value。
Entry[] table为ThreadLocal的属性，由ThreadLocalMap维护

//Thread类
class Thread implements Runnable {//ThreadLocalMap是Thread的成员变量ThreadLocal.ThreadLocalMap threadLocals = null;｝//ThreadLocal类       
public class ThreadLocal<T> {//Entry数组是ThreadLocal的成员变量，该数组由ThreadLocalMap维护private Entry[] table;//静态内部类ThreadLocalMap
static class ThreadLocalMap {//Entry是ThreadLocalMap的静态内部类，注意，Entry继承了弱引用（如果没有被强引用关联，下一次GC会被回收）static class Entry extends WeakReference<ThreadLocal<?>> {/** The value associated with this ThreadLocal. */Object value;Entry(ThreadLocal<?> k, Object v) {super(k);value = v;}}
}
}

2.2ThreadLocal类的set()方法

通过源码可以看到，ThreadLocalMap维护了Entry数组，Entry是k-v形式，key为ThreadLocal，value为我们传入的值，当同一个线程对同一个ThreadLocal进行两次set时，value会被覆盖。

获取当前线程，根据当前线程获取ThreadLocalMap
判断ThreadLocalMap是否存在
存在则将ThreadLocal作为key，传入的值为value，存入ThreadLocalMap的Entry中
不存在则根据ThreadLocalMap构造函数创建ThreadLocalMap并将ThreadLocal作为key，传入的值为value，存入ThreadLocalMap的Entry中

    public void set(T value) {Thread t = Thread.currentThread();//获取当前线程tThreadLocalMap map = getMap(t);//根据当前线程获取到ThreadLocalMapif (map != null)map.set(this, value);//如果map不为空，则将当前对象ThreadLocal作为key，传入的值为value存入ThreadLocalMap中elsecreateMap(t, value);//如果map为空，则创建ThreadLocalMap对象后，再将k-v存入ThreadLocalMap中}//该方法位于ThreadLocal中ThreadLocalMap getMap(Thread t) {return t.threadLocals;//根据线程t获取Thrad的ThreadLocalMap}//该方法位于ThreadLocal中void createMap(Thread t, T firstValue) {t.threadLocals = new ThreadLocalMap(this, firstValue);//调用ThreadLocalMap构造函数，this表示当前类ThreadLocal}//该方法位于ThreadLocal中，该方法位于ThreadLocal中构造函数维护这Entry数组tableThreadLocalMap(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);}

2.3ThreadLocal类的get()方法

获取当前线程t
根据线程t获取ThradLocalMap map
map存在则获取Entry，Entry存在获取value
map不存在，初始化ThradLocalMap并将ThreadLocal作为kay，valeu为null存进ThreadLocalMap中，返回value也就是null。
（调用get()方法时，ThreadLocalMap没有初始化则会初始化并ThreadLocal作为kay，valeu为null存进ThreadLocalMap中）

public T get() {Thread t = Thread.currentThread();//获取当前线程ThreadLocalMap map = getMap(t);if (map != null) {ThreadLocalMap.Entry e = map.getEntry(this);//map不为空，获取Entryif (e != null) {//entry不为空。返回value@SuppressWarnings("unchecked")T result = (T)e.value;return result;}}return setInitialValue();//map为空，初始化threadLocals成员变量的值，也就是初始化把thread Local为key，value=null塞进entry}private T setInitialValue() {T value = initialValue(); //初始化value的值Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); //以当前线程为key，获取threadLocals成员变量，它是一个ThreadLocalMapif (map != null)map.set(this, value);  //K，V设置到ThreadLocalMap中elsecreateMap(t, value); //实例化threadLocals成员变量return value;//返回null}protected T initialValue() {return null;}

2.4ThreadLocal类的remove()方法

获取当前线程，根据当前线程获取ThreadLocalMap
如果map部位空，则删除map中指定的的Entry

public void remove() {ThreadLocalMap m = getMap(Thread.currentThread());//获取当前线程的ThreadLocalMap变量if (m != null)m.remove(this);//对象不为空，则删除
}ThreadLocalMap getMap(Thread t) {return t.threadLocals;
}
private void remove(ThreadLocal<?> key) {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)]) {if (e.get() == key) {e.clear();expungeStaleEntry(i);return;}}
}

2.5面试：说一说ThreadLocal原理、Thread如何实现线程隔离的

ThreadLocal叫本地线程变量，作用就是当多线程访问共享变量时，起到线程隔离的作用，每个线程都有自己的一个副本，且之间不被共享，这种方式采用的是空间换时间的方式。目的是保证线程安全，采用空间换时间的方式保证线程安全。

每个线程Thread都有一个成员变量ThreadLocal.ThreadLocalMap thradLocals。也就是说每个线程都有一个ThreadLocalMap，这个ThreadLocalMap是ThreadLocal的静态内部类，他维护者Entry对象数组，Entry对象存储方式是k-v的形式。k为ThreadLocal，V为我我们set进去的值。

在并发场景下，每个线程在往ThreadLocal里面设置值得时候，实际就是存进自己的thradLocals属性中，以ThreadLocal为key，set进去的值为value。实现线程隔离。

三、深究ThreadLocal

1.为什么不直接用线程id作为ThreadLocalMap的key呢？

ThreadLocalMap是Thread的属性，维护着Entry数组，Entry的key是ThradLocal，value为我们set入的值。

如果将线程id作为key，那么当一个Thread有多个ThreadLocal进行set()的时候，无法区分value是哪个ThreadLocal的，或者说无论多少个ThreadLocal，每次set进去，由于key都是ThreadId，会导致每次set都会被覆盖。

如图所示，一个key对应多个ThreadLocal。ThreadLocal-1 set()的时候key为Thread，ThreadLocal-1 set()的时候key依然为Thread

2.ThreadLocal导致内存泄漏的原因

ThreadLocal导致内存泄漏愿意你有两个

使用完后没有remove()，由于ThreadLocalMap 的生命周期跟 Thread 一样长，对于重复利用的线程来说（例如核心线程池中的线程），如果没有手动删除（调用remove()方法），会导致Entry对象越来越多，从而导致内存泄漏．
第二种原因下面讲解

Entry类继承了弱引用，super(k);使ThreadLocal也是一个弱引用

static class Entry extends WeakReference<ThreadLocal<?>> {/** The value associated with this ThreadLocal. */Object value;Entry(ThreadLocal<?> k, Object v) {super(k);value = v;}
}

ThreadLocal引用示意图

ThreadLocalMap使用ThreadLocal的弱引用作为key，当ThreadLocal变量被手动设置为null，即一个ThreadLocal没有外部强引用来引用它，当系统GC时，ThreadLocal一定会被回收。
这样的话，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value
如果当前线程再迟迟不结束的话(比如线程池的核心线程)，这些key为null的Entry的value就会一直存在一条强引用链：Thread变量 -> Thread对象 -> ThreaLocalMap -> Entry -> value -> Object 永远无法回收，造成内存泄漏。

当Thread手动设置为null后的因用链

此时，堆中的ThreadLocal只存在弱引用，再下一次GC时会被回收。回收后，Entry中的key=null，这个Entry就没有办法被访问。导致内存泄漏。

3.ThreadLocalMap在设计中有没有考虑到内存泄漏这点呢？

实际上ThreadLocalMap在设计的时候就考虑到这个情况了，所以ThreadLocal的get、set方法中加了一些防护措施。在执行set、get方法的时候，会清楚线程中ThreadLocalMap中key为null的Entry。

ThreadLocal的set()方法防止内存泄漏措施

  private void set(ThreadLocal<?> key, Object value) {// We don't use a fast path as with get() because it is at// least as common to use set() to create new entries as// it is to replace existing ones, in which case, a fast// path would fail more often than not.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();if (k == key) {e.value = value;return;}if (k == null) {replaceStaleEntry(key, value, i);return;}}tab[i] = new Entry(key, value);int sz = ++size;//触发一次Log2(N)复杂度的扫描,目的是清除过期Entry  if (!cleanSomeSlots(i, sz) && sz >= threshold)rehash();}

ThreadLocal的get()方法防止内存泄露措施

public T get() {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null) {//去ThreadLocalMap获取Entry，方法里面有key==null的清除逻辑ThreadLocalMap.Entry e = map.getEntry(this);if (e != null) {@SuppressWarnings("unchecked")T result = (T)e.value;return result;}}return setInitialValue();}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//其中有key为null的清楚逻辑return getEntryAfterMiss(key, i, e);}private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {Entry[] tab = table;int len = tab.length;while (e != null) {ThreadLocal<?> k = e.get();if (k == key)return e;if (k == null)// Entry的key为null,则表明没有外部引用,且被GC回收,是一个过期EntryexpungeStaleEntry(i);elsei = nextIndex(i, len);e = tab[i];}return null;}

4.在使用ThreadLocal中，我们应该注意什么

将ThreadLocal变量定义成private static的，这样的话ThreadLocal的生命周期就更长，由于一直存在ThreadLocal的强引用，所以ThreadLocal也就不会被回收，也就能保证任何时候都能根据ThreadLocal的弱引用访问到Entry的value值，然后remove它，防止内存泄露
每次使用完ThreadLocal，都调用它的remove()方法，清除数据。

5.key是弱引用，GC回收会影响ThreadLocal的正常工作嘛

弱引用:具有弱引用的对象拥有更短暂的生命周期。如果一个对象只有弱引用存在了，则下次GC将会回收掉该对象（不管当前内存空间足够与否）

当然不会，因为还有ThreadLocal强引用着它，是不会被GC回收的，除非手动将ThradLocal置为null

验证

package com.jhq.threadLocal;import java.lang.ref.WeakReference;
/*** @BelongsProject: study* @BelongsPackage: com.jhq.threadLocal* @Author: jianghq* @CreateTime: 2023-02-24  17:02* @Description: ThreadLocal的key既然是弱引用.会不会GC贸然把key回收掉，进而影响ThreadLocal的正常使用？ 不会* @Version: 1.0*/
public class WeakReferenceTest {public static void main(String[] args) {Object object = new Object();WeakReference<Object> testWeakReference = new WeakReference<>(object);System.out.println("GC回收之前，弱引用："+testWeakReference.get());//触发系统垃圾回收for(int i=0;i<100;i++){//我们只能建议GC回收，并不能百分之百保证真的回收System.gc();}System.out.println("GC回收之后，弱引用："+testWeakReference.get());//手动设置为object对象为nullobject=null;System.gc();System.out.println("对象object设置为null，GC回收之后，弱引用："+testWeakReference.get());}
}
输出：GC回收之前，弱引用：java.lang.Object@cc34f4dGC回收之后，弱引用：java.lang.Object@cc34f4d对象object设置为null，GC回收之后，弱引用：null

6.Entry的key为什么要设计成弱引用呢，为什么不使用强引用

官方回答

o help deal with very large andlong-lived usages, the hash table entries use WeakReferences for keys.

为了应对非常大和长时间的用途，哈希表使用弱引用的 key。

6.1Entry的key如果使用强引用

先看看引用图

正这种情况，由于ThreadLocalMap生命周期和Thread一样长，使用强引用之后，只要Thrad存在，那么Entry就会一直存在内存中，如果线程为核心线程池中的线程，Entry就会一直存在，导致内存泄漏。

6.2为什么要设计成弱引用

如果Key使用弱引用：ThreadLocal置为null，因为ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value则在下一次ThreadLocalMap调用set,get，remove的时候会被清除。

6.3四种引用类型

强引用：我们new出来的对象就是强引用，例如Object o=new Onject();强引用不会被GC回收。
软引用：一个对象只有软引用时，内存空间足够的情况下不会被回收，当内存不足时会被回收。
弱引用：当对象只有弱引用时，下一次GC时会被回收。
虚引用：如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。

7.我们希望父子线程之间共享数据，应该怎么做呢

7.1InheritableThreadLocal

使用InheritableThreadLocal

public class InheritableThreadLocalTest {public static void main(String[] args) {ThreadLocal threadLocal=new ThreadLocal();InheritableThreadLocal inheritableThreadLocal=new InheritableThreadLocal();threadLocal.set("main线程.ThreadLocal");inheritableThreadLocal.set("main线程.InheritableThreadLocal");new Thread(()->{threadLocal.set(Thread.currentThread().getName()+"ThreadLocal");inheritableThreadLocal.set(Thread.currentThread().getName()+"InheritableThreadLocal");}).start();new Thread(()->{System.out.println("当前线程"+Thread.currentThread().getName()+"===="+threadLocal.get());System.out.println("当前线程"+Thread.currentThread().getName()+"===="+inheritableThreadLocal.get());}).start();}
}//输出
当前线程Thread-0====null
当前线程Thread-0====main线程.InheritableThreadLocal

可以看出，ThreadLocal在父子线程之间是不共享的。InheritableThreadLocal可以在父子线程之间共享。但仅限于父子线程之间。

7.2InheritableThreadLocal是如何实现父子线程之间共享的

InheritableThreadLocal是Thread的成员变量，返回类型也是ThreadLocal.ThreadLocalMap

    /* ThreadLocal values pertaining to this thread. This map is maintained* by the ThreadLocal class. */ThreadLocal.ThreadLocalMap threadLocals = null;/** InheritableThreadLocal values pertaining to this thread. This map is* maintained by the InheritableThreadLocal class.*/ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

Thread的init方法

    private void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc) {//>.....衡略//如果父线程的inheritableThreadLocals不为空，则将inheritableThreadLocals赋值给子类if (parent.inheritableThreadLocals != null)this.inheritableThreadLocals =ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);/* Stash the specified stack size in case the VM cares */this.stackSize = stackSize;/* Set thread ID */tid = nextThreadID();}static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {return new ThreadLocalMap(parentMap);}