Java多线程之ThreadLocal浅析

顺亿

2026-09-14 • 👁 0人浏览过

目录介绍什么是ThreadLocal？

ThreadLocal 的作用是什么？

如何使用ThreadLocal如何创建一个ThreadLocal实例ThreadLocal的实现原理ThreadLocal的内部数据结构Thread类:ThreadLocal的set()方法：ThreadLocalMap和ThreadLocalMap.Entry的实现ThreadLocalMap.set()方法ThreadLocalMap.get()方法ThreadLocalMap.remove()方法ThreadLocal的垃圾回收机制ThreadLocal的使用场景参数透传全局存储用户信息（项目中用到）

解决线程安全问题介绍什么是ThreadLocal？

ThreadLocal叫做线程变量，用于在多线程环境下创建线程本地变量。

通俗的讲，ThreadLocal可以让你在同一个线程中创建一个变量，并且这个变量对于该线程是唯一的，其他线程无法访问到这个变量。

这种方式能够有效地避免多线程之间的变量冲突问题，使得线程本地变量的访问变得更加安全和高效。

例如，在一个线程池中，每个线程需要维护自己的状态，这时就可以使用ThreadLocal来创建线程本地变量来存储状态信息。

ThreadLocal 的作用是什么？

在多线程编程中，由于不同线程之间共享内存，如果多个线程访问同一个变量，就会发生竞争条件，可能会导致数据不一致或者死锁等问题。使用ThreadLocal可以解决这个问题，因为它可以为每个线程创建一个独立的变量副本，每个线程都可以访问自己的变量副本，而不会影响其他线程的变量。这种方式可以有效地避免多线程之间的变量冲突问题，提高了程序的可靠性和性能。ThreadLocal常用于实现线程安全的单例模式，以及在多线程环境下对共享数据的缓存。

如何使用ThreadLocal如何创建一个ThreadLocal实例直接上代码:public class ThreadLocalDemo {private static ThreadLocal threadLocal = new ThreadLocal<>();


public static void main(String[] args) {new Thread(() -> {System.out.println("thread1 before set: " + threadLocal.get());threadLocal.set("AAAAA");System.out.println("thread1 after set: " + threadLocal.get());threadLocal.remove();System.out.println("thread1 after remove: " + threadLocal.get());}).start();
new Thread(() -> {System.out.println("thread1 before set: " + threadLocal.get());threadLocal.set("BBBBB");System.out.println("thread2 after set: " + threadLocal.get());threadLocal.remove();System.out.println("thread2 after remove: " + threadLocal.get());}).start();
System.out.println("main thread before set: " + threadLocal.get());threadLocal.set("Main");System.out.println("main after set: " + threadLocal.get());threadLocal.remove();System.out.println("main after remove: " + threadLocal.get());}}
程序输出:

thread1 before set: null main thread before set: null main after set: Main thread1 before set: null thread1 after set: AAAAA thread1 after remove: null thread2 after set: BBBBB thread2 after remove: null main after remove: null创建ThreadLocal实例的方式非常简单，只需要使用Java中的ThreadLocal类的构造函数即可。

上面的代码创建了一个ThreadLocal实例，该实例可以存储String类型的值。在使用ThreadLocal之前，需要先调用它的set()方法来初始化一个线程本地变量, 否则get()方法得到的值就是null。

从代码中可以看到, 我们在main方法中分别创建了2个线程, 三个线程分表获取了自己线程存放的变量，他们之间变量的获取并不会错乱。

如果在当前线程中尚未设置该值或者已经调用remove()方法删除值，则返回null。

需要注意的是，每个ThreadLocal对象只能存储一个值，如果需要存储多个值，则需要创建多个ThreadLocal对象。

ThreadLocal与Synchronized的区别ThreadLocal和Synchronized都是Java中用于处理多线程并发访问的工具，但它们的作用和实现方式有很大的区别。

作用不同：ThreadLocal主要是用来创建线程本地变量，解决多线程并发访问时的变量冲突问题；而Synchronized则是一种同步机制，用于保护共享资源，防止多线程之间的竞争条件。

实现方式不同：ThreadLocal通过为每个线程创建独立的变量副本，使得每个线程之间互不干扰，从而解决多线程访问共享变量时的线程安全问题。而Synchronized则是通过互斥访问来实现同步的，即多个线程同时只能有一个线程访问共享资源。

应用场景不同：ThreadLocal适用于需要在多个线程中使用独立的变量的场景，如线程池中的线程状态管理，以及Web应用中的Session管理等；而Synchronized则适用于需要保护共享资源的场景，如多个线程同时访问同一个数据结构，或者需要保证某个方法在同一时刻只能被一个线程访问等。

性能影响不同：ThreadLocal相对于Synchronized来说性能更好，因为它只涉及到线程本地变量的访问和赋值操作，不需要进行锁竞争和上下文切换等操作。而Synchronized则需要进行锁竞争和上下文切换等操作，会对性能产生一定的影响。

ThreadLocal的优点：线程安全：每个线程都拥有自己的变量副本，不会受到其他线程的影响，可以避免线程安全问题。

性能高：ThreadLocal使用了空间换时间的方式，每个线程都有自己的变量副本，不需要进行加锁和解锁操作，因此性能更高。

代码简洁：使用ThreadLocal可以避免复杂的同步控制逻辑。

加锁的优点：

保证数据一致性：通过加锁可以保证共享资源在多线程环境下的正确性，避免出现数据不一致的情况。

线程同步：在加锁过程中，线程会被阻塞，等待锁的释放，保证了线程同步。

ThreadLocal的缺点：内存泄漏：ThreadLocal使用静态的内部Map来存储变量副本，如果不及时清理，会导致内存泄漏问题(后续展开介绍)。

难以调试：由于每个线程都有自己的变量副本，因此在调试过程中，需要考虑多个线程的情况，会增加调试的难度。

加锁的缺点：

性能问题：在高并发情况下，加锁会导致线程的阻塞，从而影响系统的性能。

容易导致死锁：如果加锁的操作不正确，可能会导致死锁问题，需要谨慎使用。

综合来看，ThreadLocal适合处理线程私有的数据，而加锁适合处理共享的资源，具体应该根据业务需求来选择。

ThreadLocal的实现原理ThreadLocal的内部数据结构

直接查看源码:Thread类:public class Thread implements Runnable {//MAP ThreadLocal.ThreadLocalMap threadLocals = null;

//用于父子线程变量同步, 后续介绍ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;}ThreadLocal的set()方法： public void set(T value) {//获取当前线程Thread t = Thread.currentThread();//封装方法从获取线程中的ThreadLocalMap//为什么封装方法呢? 为了后面扩展inheritableThreadLocals ThreadLocalMap map = getMap(t);//之前有创建过, 直接set if (map != null) map.set(this, value);else//之前没有创建, 新建Map并设置值createMap(t, value);}

ThreadLocalMap getMap(Thread t) {return t.threadLocals;}从源码中我们可以看到, 在set方法中, 我们先是获取到当前线程, 然后以当前线程为入参调用getMap方法, 并获取thread线程中的ThreadLocalMap属性。如果map属性不为空，则直接更新value值，如果map为空，则实例化threadLocalMap, 并将value值初始化。

那么threadLocalMap又是什么呢? 我们接着往下看。

ThreadLocalMap和ThreadLocalMap.Entry的实现public class ThreadLocal {


static class ThreadLocalMap {
//继承弱应用, 方便垃圾回收static class Entry extends WeakReference> {
/** The value associated with this ThreadLocal. */ Object value;

Entry(ThreadLocal k, Object v) {super(k);value = v;}}//数组, 用于存储多组数据private Entry[] table;}}从代码我们可以看到, threadLocalMap是ThreadLocal中的一个静态内部类, 在threadLocalMap又维护了一个名叫table的Entry数组。

Entry是什么呢?Entry是一组组数据对, 而且继承的弱引用。在Entry内部使用ThreadLocal作为key，使用我们设置的value作为value。

key 就是 ThreadLocal，肯定不为空，但也是弱引用的。

也就是说，当 key 为 null 时，说明 ThreadLocal 已经被回收了，对应的 Entry 就应该被清除了。

ThreadLocalMap.set()方法private void set(ThreadLocal key, Object value) {Entry[] tab = table;int len = tab.length;//根据hashCode与长度计算索引位置int i = key.threadLocalHashCode & (len-1);


for (Entry e = tab[i];e != null;// 如果下标冲突, 索引+1继续查找e = tab[i = nextIndex(i, len)]) {ThreadLocal k = e.get();
//找到直接返回值if (k == key) {e.value = value;return;}
if (k == null) {// key 为空, 说明 对应的 ThreadLocal 已经回收了.
// 可以复用当前位置.
// 有两种情况:1\. entry 存在, 在这个过时位置的后面. 所以需要置换到这个位置// 2.不存在, 直接放到这个位置replaceStaleEntry(key, value, i);// 因为是替换， 所以size 要么不变，要么减少。
return;}}

// 没找到已存在的, 也没找到可以替换的过时. 则直接新建tab[i] = new Entry(key, value);int sz = ++size;if (!cleanSomeSlots(i, sz) && sz >= threshold)// 如果没有清除过时 entry, 并且超过阈值. 则进行先尝试缩小,不行则扩容rehash();}在ThreadLocalMap中的set方法与构造方法能看到以下代码片段。

int i = key.threadLocalHashCode & (len-1)int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)简而言之就是将threadLocalHashCode进行一个位运算（取模）得到索引i，threadLocalHashCode代码如下。

public class ThreadLocal {private final int threadLocalHashCode = nextHashCode();


private static AtomicInteger nextHashCode =  new AtomicInteger();private static final int HASH_INCREMENT = 0x61c88647;
/*** Returns the next hash code.

*/ private static int nextHashCode() {//自增return nextHashCode.getAndAdd(HASH_INCREMENT);}}因为static的原因，在每次new ThreadLocal()时因为threadLocalHashCode的初始化，会使threadLocalHashCode值自增一次，增量为0x61c88647。

0x61c88647是斐波那契散列乘数,它的优点是通过它散列(hash)出来的结果分布会比较均匀，可以很大程度上避免hash冲突。

有兴趣可以深入研究下去, 这里就不过多赘述了, 这里这样运算就是为了避免索引下标冲突。

总结一下:对于某一ThreadLocal来讲，他的索引值i是确定的，在不同线程之间访问时访问的是不同的table数组的同一位置即都为table[i]，只不过这个不同线程之间的table是独立的。

对于同一线程的不同ThreadLocal来讲，这些ThreadLocal实例共享一个table数组，然后每个ThreadLocal实例在table中的索引i是不同的。

ThreadLocalMap.get()方法public T get() {//获取当前线程Thread t = Thread.currentThread();//获取ThreadLocalMap ThreadLocalMap map = getMap(t);if (map != null) {//通过ThreadLocal获取Entry ThreadLocalMap.Entry e = map.getEntry(this);//返回值if (e != null) {@SuppressWarnings("unchecked") T result = (T)e.value;return result;}}//设置初始值--null return setInitialValue();}

private Entry getEntry(ThreadLocal key) {//计算下标, 通过下标从Entry数组中直接取值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);}理解了set方法，get方法也就清楚明了，直接通过计算出索引直接从数组对应位置读取即可。

ThreadLocalMap.remove()方法public void remove() {ThreadLocalMap m = getMap(Thread.currentThread());if (m != null) m.remove(this);}ThreadLocal的垃圾回收机制ThreadLocal对象的垃圾回收机制比较特殊，主要涉及到两个对象：ThreadLocal对象和ThreadLocalMap对象。

每个ThreadLocal对象都会在当前线程的ThreadLocalMap中创建一个Entry对象，这个Entry对象包含了ThreadLocal对象和其对应的值。当ThreadLocal对象没有被其他对象引用，并且当前线程结束时，这个ThreadLocal对象会被标记为可回收的，并且被添加到一个特殊的ReferenceQueue中。

当垃圾回收器扫描到ReferenceQueue中的ThreadLocal对象时，它会将ThreadLocal对象对应的Entry对象从ThreadLocalMap中删除，并且清除Entry对象中对ThreadLocal对象和值的引用，从而使得ThreadLocal对象和值都能够被回收。

需要注意的是，虽然ThreadLocal对象被回收了，但是它在ThreadLocalMap中对应的Entry对象并没有被立即清除，只有在下一次调用ThreadLocalMap的set()、get()或remove()方法时才会触发Entry对象的清除操作。这是因为ThreadLocalMap中的Entry对象使用了弱引用，只有在下一次调用ThreadLocalMap时才会被垃圾回收器扫描到并被清除。

因此，使用ThreadLocal对象时需要注意，在不再需要使用ThreadLocal对象时，应该及时调用remove()方法，以便及时清除ThreadLocalMap中对应的Entry对象，从而避免内存泄漏。

ThreadLocal的使用场景参数透传当我们在写API接口的时候，通常Controller层会接受来自前端的入参，当这个接口功能比较复杂的时候，可能我们调用的Service层内部还调用了很多其他的很多方法，通常情况下，我们会在每个调用的方法上加上需要传递的参数。

但是如果我们将参数存入ThreadLocal中，那么就不用显式的传递参数了，而是只需要ThreadLocal中获取即可。

这个场景其实使用的比较少，一方面显式传参比较容易理解，另一方面我们可以将多个参数封装为对象去传递。

全局存储用户信息（项目中用到）

在现在的系统设计中，前后端分离已基本成为常态，分离之后如何获取用户信息就成了一件麻烦事，通常在用户登录后，用户信息会保存在Session或者Token中。这个时候，我们如果使用常规的手段去获取用户信息会很费劲，拿Session来说，我们要在接口参数中加上HttpServletRequest对象，然后调用 getSession方法，且每一个需要用户信息的接口都要加上这个参数，才能获取Session，这样实现就很麻烦了。

在实际的系统设计中，我们肯定不会采用上面所说的这种方式，而是使用ThreadLocal，我们会选择在拦截器的业务中，获取到保存的用户信息，然后存入ThreadLocal，那么当前线程在任何地方如果需要拿到用户信息都可以使用ThreadLocal的get()方法 (异步程序中ThreadLocal是不可靠的, 后续会出文章详解)。

当用户登录后，会将用户信息存入Token中返回前端，当用户调用需要授权的接口时，需要在header中携带 Token，然后拦截器中解析Token，获取用户信息，调用自定义的类存入ThreadLocal中，当请求结束的时候，将ThreadLocal存储数据清空(这一点很重要，否则会产生内存泄漏)，中间的过程无需再关注如何获取用户信息，只需要使用工具类的get方法即可。

解决线程安全问题ThreadLocal的设计天然就做到了线程隔离。所以就不会出现线程安全问题。

以上就是Java多线程之ThreadLocal浅析的详细内容，更多关于Java多线程ThreadLocal的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:Java多线程之ThreadLocal原理总结Java多线程 ThreadLocal原理解析java多线程编程之InheritableThreadLocal Java多线程编程中ThreadLocal类的用法及深入Java多线程编程之ThreadLocal线程范围内的共享变量