线程私有变量ThreadLocal详解

本文已收录至Github               ，推荐阅读 ? Java随想录

微信公众号：Java随想录

CSDN： 码农BookSea

烈火试真金  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 ，逆境试强者               。——塞内加

什么是ThreadLocal

首先看下ThreadLocal的使用示例：

public class ThreadLocalTest { private static ThreadLocal<String> threadLocal = new ThreadLocal<>(); public static void main(String[] args) { Thread thread1 = new Thread(() -> { threadLocal.set("本地变量1"); print("thread1"); System.out.println("线程1的本地变量的值为:"+threadLocal.get()); }); Thread thread2 = new Thread(() -> { threadLocal.set("本地变量2"); print("thread2"); System.out.println("线程2的本地变量的值为:"+threadLocal.get()); }); thread1.start(); thread2.start(); } public static void print(String s){ System.out.println(s+":"+threadLocal.get()); }

执行结果如下

我们从 Thread 类讲起















，在 Thread 类中有维护两个 ThreadLocal.ThreadLocalMap 对象
  
  
  
  
  
  
  
 ，分别是：threadLocals 和inheritableThreadLocals  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 。

/* 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;

初始它们都为 null  
  
  
  
  
  
  
  ，只有在调用 ThreadLocal 类的 set 或 get 时才创建它们















。ThreadLocalMap可以理解为线程私有的HashMap
  
  
  
  
  
  
  
 。

ThreadLoalMap是ThreadLocal中的一个静态内部类
 


 


 


 


 


 


 


 

，类似HashMap的数据结构
 
 
 
 
 
 
 
，但并没有实现Map接口  
  
  
  
  
  
  
  。

ThreadLoalMap中初始化了一个大小16的Entry数组   
   
   
   
   
   
   
   ，Entry对象用来保存每一个key-value键值对
 


 


 


 


 


 


 


 

。key是ThreadLocal对象
 
 
 
 
 
 
 
。

Entry用来保存数据 
 

 

 

 

 

 

 

 
，而且还是继承的弱引用   
   
   
   
   
   
   
   。在Entry内部使用ThreadLocal作为key

 

 

 

 

 

 

 

，使用我们设置的value作为value
 

 

 

 

 

 

 

 
。

ThreadLocal 原理

set()方法

当我们调用 ThreadLocal 的 set() 方法时实际是调用了当前线程的 ThreadLocalMap 的 set() 方法

 

 

 

 

 

 

 

。ThreadLocal 的 set() 方法中                ，会进一步调用Thread.currentThread() 获得当前线程对象 
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 ，然后获取到当前线程对象的ThreadLocal















，判断是不是为空                       ，为空就先调用creadMap()创建再set(value)创建 ThreadLocalMap 对象并添加变量                。不为空就直接set(value) 
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 。

这种保证线程安全的方式称为线程封闭















。线程只能看到自己的ThreadLocal变量                       。线程之间是互相隔离的 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 。

get()方法

其中get()方法用来获取与当前线程关联的ThreadLocal的值 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ，如果当前线程没有该ThreadLocal的值























，则调用initialValue函数获取初始值返回               ，所以一般我们使用时需要继承该函数  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 ，给出初始值（不重写的话默认返回Null）























。

主要有以下几步：

获取当前的Thread对象















，通过getMap获取Thread内的ThreadLocalMap 如果map已经存在
  
  
  
  
  
  
  
 ，以当前的ThreadLocal为键  
  
  
  
  
  
  
  ，获取Entry对象
 


 


 


 


 


 


 


 

，并从从Entry中取出值 否则
 
 
 
 
 
 
 
，调用setInitialValue进行初始化               。 /** * Returns the value in the current threads copy of this * thread-local variable. If the variable has no value for the * current thread, it is first initialized to the value returned * by an invocation of the {@link #initialValue} method. * * @return the current threads value of this thread-local */ public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } return setInitialValue(); }

我们可以重写initialValue()   
   
   
   
   
   
   
   ，设置初始值  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 。

private static final ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>(){ @Override protected Integer initialValue() { return Integer.valueOf(0); } }

remove()方法

最后一个需要探究的就是remove方法
 

 

 

 

 

 

 

 
，它用于在map中移除一个不用的Entry















。也是先计算出hash值

 

 

 

 

 

 

 

，若是第一次没有命中                ，就循环直到null
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 ，在此过程中也会调用expungeStaleEntry清除空key节点
  
  
  
  
  
  
  
 。代码如下：

public void remove() { ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null) m.remove(this); } /** * Remove the entry for key. */ 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; } } }

实际上 ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用















，弱引用的特点是                       ，如果这个对象只存在弱引用 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ，那么在下一次垃圾回收的时候必然会被清理掉  
  
  
  
  
  
  
  。

所以如果 ThreadLocal 没有被外部强引用的情况下























，在垃圾回收的时候会被清理掉的               ，这样一来 ThreadLocalMap中使用这个 ThreadLocal 的 key 也会被清理掉
 


 


 


 


 


 


 


 

。但是  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 ，value 是强引用















，不会被清理
  
  
  
  
  
  
  
 ，这样一来就会出现 key 为 null 的 value
 
 
 
 
 
 
 
。出现内存泄漏的问题   
   
   
   
   
   
   
   。

在执行 ThreadLocal 的 set               、remove  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 、rehash 等方法时  
  
  
  
  
  
  
  ，它都会扫描 key 为 null 的 Entry
 


 


 


 


 


 


 


 

，如果发现某个 Entry 的 key 为 null
 
 
 
 
 
 
 
，则代表它所对应的 value 也没有作用了   
   
   
   
   
   
   
   ，所以它就会把对应的 value 置为 null
 

 

 

 

 

 

 

 
，这样

 

 

 

 

 

 

 

，value 对象就可以被正常回收了
 

 

 

 

 

 

 

 
。但是假设 ThreadLocal 已经不被使用了                ，那么实际上 set















、remove
  
  
  
  
  
  
  
 、rehash 方法也不会被调用
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 ，与此同时















，如果这个线程又一直存活  
  
  
  
  
  
  
  、不终止的话                       ，那么刚才的那个调用链就一直存在 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ，也就导致了 value 的内存泄漏

 

 

 

 

 

 

 

。

ThreadLocal 的Hash算法

ThreadLocalMap类似HashMap























，它有自己的Hash算法                。

private final int threadLocalHashCode = nextHashCode(); private static final int HASH_INCREMENT = 0x61c88647; private static int nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT); } public final int getAndAdd(int delta) { return unsafe.getAndAddInt(this, valueOffset, delta); }

HASH_INCREMENT这个数字被称为斐波那契数 也叫 黄金分割数               ，带来的好处就是 hash 分布非常均匀
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 。

每当创建一个ThreadLocal对象  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 ，这个ThreadLocal.nextHashCode 这个值就会增长 0x61c88647 















。

讲到Hash就会涉及到Hash冲突















，跟HashMap通过链地址法不同的是
  
  
  
  
  
  
  
 ，ThreadLocal是通过线性探测法/开放地址法来解决hash冲突                       。

ThreadLocal 1.7和1.8的区别

ThreadLocal 1.7版本的时候  
  
  
  
  
  
  
  ，entry对象的key是Thread 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 。

1.8版本entry的key是ThreadLocal























。

1.8版本的好处 ：当Thread销毁的时候
 


 


 


 


 


 


 


 

，ThreadLocalMap也会随之销毁
 
 
 
 
 
 
 
，减少内存的使用               。因为ThreadLocalMap是在Thread里面的   
   
   
   
   
   
   
   ，所以只要Thread消失了
 

 

 

 

 

 

 

 
，那ThreadLocalMap就不复存在了  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 。

ThreadLocal 的问题

ThreadLocal 内存泄露问题

在 ThreadLocalMap 中的 Entry 的 key 是对 ThreadLocal 的 WeakReference 弱引用

 

 

 

 

 

 

 

，而 value 是强引用















。当 ThreadLocalMap 的某 ThreadLocal 对象只被弱引用                ，GC 发生时该对象会被清理
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 ，此时 key 为 null















，但 value 为强引用不会被清理
  
  
  
  
  
  
  
 。此时 value 将访问不到也不被清理掉就可能会导致内存泄漏  
  
  
  
  
  
  
  。

注意构造函数里的第一行代码super(k)                       ，这意味着ThreadLocal对象是一个弱引用

/** * The entries in this hash map extend WeakReference, using * its main ref field as the key (which is always a * ThreadLocal object). Note that null keys (i.e. entry.get() * == null) mean that the key is no longer referenced, so the * entry can be expunged from table. Such entries are referred to * as "stale entries" in the code that follows. */ static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }

因此我们使用完 ThreadLocal 后最好手动调用 remove() 方法
 


 


 


 


 


 


 


 

。但其实在 ThreadLocalMap 的实现中以及考虑到这种情况 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ，因此在调用 set()
 


 


 


 


 


 


 


 

、get()
 
 
 
 
 
 
 
、remove() 方法时























，会清理 key 为 null 的记录
 
 
 
 
 
 
 
。

为什么使用弱引用而不是强引用?

为什么采用了弱引用的实现而不是强引用呢？

注释上有这么一段话：为了协助处理数据比较大并且生命周期比较长的场景               ，hash table的条目使用了WeakReference作为key   
   
   
   
   
   
   
   。

所以  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 ，弱引用反而是为了解决内存存储问题而专门使用的
 

 

 

 

 

 

 

 
。

实际上















，采用弱引用反而多了一层保障
  
  
  
  
  
  
  
 ，ThreadLocal被清理后key为null  
  
  
  
  
  
  
  ，对应的value在下一次ThreadLocalMap调用set   
   
   
   
   
   
   
   、get
 


 


 


 


 


 


 


 

，就算忘记调用 remove 方法
 
 
 
 
 
 
 
，弱引用比强引用可以多一层保障

 

 

 

 

 

 

 

。

所以   
   
   
   
   
   
   
   ，内存泄露的根本原因是是否手动清除操作
 

 

 

 

 

 

 

 
，而不是弱引用                。

ThreadLocal 父子线程继承

异步场景下无法给子线程共享父线程的线程副本数据

 

 

 

 

 

 

 

，可以通过 InheritableThreadLocal 类解决这个问题
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 。

它的原理就是子线程是通过在父线程中调用 new Thread() 创建的                ，在 Thread 的构造方法中调用了 Thread的init 方法
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 ，在 init 方法中父线程数据会复制到子线程（ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);）















。

代码示例：

public class InheritableThreadLocalDemo { public static void main(String[] args) { ThreadLocal<String> threadLocal = new ThreadLocal<>(); ThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>(); 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(); } }

但是我们做异步处理都是使用线程池















，线程池会复用线程会导致问题出现                       。我们可以使用阿里巴巴的TTL解决这个问题 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 。

https://github.com/alibaba/transmittable-thread-local

如果本篇博客有任何错误和建议                       ，欢迎给我留言指正























。文章持续更新 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ，可以关注公众号第一时间阅读               。