深入理解 ThreadLocal

• 介绍
• 源码分析
• • ThreadLocal 类图
  • set(T value)
  • T get()
  • 内存泄露
  • hash冲突解决
• 总结

介绍

官方介绍:
此类提供线程局部变量。这些变量与它们的正常对应变量不同，因为每个访问一个变量的线程（通过其get或set方法）都有自己的、独立初始化的变量副本。ThreadLocal实例通常是希望将状态与线程关联的类中的私有静态字段（例如，用户ID或事务ID）。
通俗理解:
ThreadLocal 是用来做线程变量隔离的。对应公共变量，当出现在多线程情况下，容易出现数据修改混乱的情况，通常的做法是加锁(Synchronize和Lock)处理，但这样的做法会降低并发性能。还有一种做法是采用ThreadLocal。它是通过空间来换时间。

源码分析

ThreadLocal 类图

ThreadLocal 的类图结构比较简单，它内部维护了一个ThreadLocalMap类，可以把ThreadLocalMap理解为一个map容器。于此同时，Thread对象里面也维护了一个ThreadLocal.ThreadLocalMap属性。

set(T value)

首先通过当前线程拿到ThreadLocalMap对象(Thread 里面有ThreadLocal.ThreadLocalMap属性，ThreadLocalMap 可以理解为一个Map对象)。然后 用当前ThreadLocal 对象为Key,T Value 为value。存入map中。

  public void set(T value) {//拿到当前线程Thread t = Thread.currentThread();//通过当前线程拿到ThreadLocalMap 对象ThreadLocalMap map = getMap(t);if (map != null)//将值放入map中。key 为当前的ThreadLocal对象map.set(this, value);else//如果通过 当前线程拿到的ThreadLocalMap对象为空，//则构造一个新的ThreadLocalMap,然后将value值放入到map中createMap(t, value);}

  ThreadLocalMap getMap(Thread t) {//getMap 拿到的就是ThreadLocalMap对象return t.threadLocals;}

static class ThreadLocalMap {static class Entry extends WeakReference> {Object value;Entry(ThreadLocal k, Object v) {super(k);value = v;}}/*** The initial capacity -- MUST be a power of two.*/private static final int INITIAL_CAPACITY = 16;/*** The table, resized as necessary.* table.length MUST always be a power of two.*/private Entry[] table;/*** The number of entries in the table.*/private int size = 0;/*** The next size value at which to resize.*/private int threshold; // Default to 0/*** Set the resize threshold to maintain at worst a 2/3 load factor.*/private void setThreshold(int len) {threshold = len * 2 / 3;}/*** Increment i modulo len.*/private static int nextIndex(int i, int len) {return ((i + 1 < len) ? i + 1 : 0);}/*** Decrement i modulo len.*/private static int prevIndex(int i, int len) {return ((i - 1 >= 0) ? i - 1 : len - 1);}.....}

 void createMap(Thread t, T firstValue) {//构造一个新的ThreadLocalMap对象。最终是将ThreadLocalMap对象赋值给了Thread的属性。// 所以我们取值的时候，都是通过当前对象来拿到ThreadLocalMap对象，//然后通过key 来获取valuet.threadLocals = new ThreadLocalMap(this, firstValue);}

 ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {//设置数组大小为16table = new Entry[INITIAL_CAPACITY];//通过key 的hash值 然后和数组大小减1进行与操作获得下标int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//构造一个entry对象赋值给数组table[i] = new Entry(firstKey, firstValue);//容量加一size = 1;//设置阈值 为初始值的2/3.setThreshold(INITIAL_CAPACITY);}

T get()

如果前面的set(T value) 方法看明白的话，那get () 方法也就是很简单了。通过当前线程，拿到它的属性ThreadLocal.ThreadLocalMap对象。然后以当前对象ThreadLocal 为key。来从map中获取value。

 public T get() {Thread t = Thread.currentThread();//通过当前线程来获取ThreadLocalMap对象ThreadLocalMap map = getMap(t);if (map != null) {//从map 中获取value.   key 为当前对象 ThreadLocalThreadLocalMap.Entry e = map.getEntry(this);if (e != null) {@SuppressWarnings("unchecked")T result = (T)e.value;return result;}}//如果通过当前对象获取的ThreadLocalMap对象为空。则构造一个新的map,并返回null.return setInitialValue();}

  private T setInitialValue() {//返回初始的null值T value = initialValue();Thread t = Thread.currentThread();//构造一个新的ThreadLocalMap对象ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value);//返回null 值return value;}

 protected T initialValue() {return null;}

内存泄露

我们来看一段ThreadLocal的代码例子。

private static final ThreadLocal userInfoThreadLocal = new ThreadLocal<>();public Response handleRequest(UserInfo userInfo) {Response response = new Response();try {// 1.用户信息set到线程局部变量中userInfoThreadLocal.set(userInfo);doHandle();} finally {// 3.使用完移除掉userInfoThreadLocal.remove();}return response;
}
//业务逻辑处理
private void doHandle () {// 2.实际用的时候取出来UserInfo userInfo = userInfoThreadLocal.get();//查询用户资产queryUserAsset(userInfo);
}

面试题: threadLocal 会出现内存溢出问题？
要分析这个问题，我们可以看下ThreadLocal 内存中的引用关系

首先ThreadLocal对象 被ThreadLocal引用 引用着，这是一个强引用。同时，entry 的key 也被ThreadLocal对象引用。此时的引用是个弱引用。

   static class ThreadLocalMap {//Entry 继承于 WeakReference，是个弱引用static class Entry extends WeakReference> {/** The value associated with this ThreadLocal. */Object value;//Entry 的key 是ThreadLocal对象，正是 Entry 继承的弱引用对象。// 即entry 的key 也是一个弱引用对象。Entry(ThreadLocal k, Object v) {super(k);value = v;}}

所以正常情况下，当threadLocal 所在的作用域结束了，工作被清理了。ThreadLocal对象就会被回收(虽然ThreadLocal对象被key引用，但是弱引用，依然会被gc回收)。然后key 就指向了null。
但是我们在使用线程池的情况下，线程使用完毕，不会被回收。所以 从Thread引用–> Thread对象 --> ThreadLocalMap–>Entry 这条引用线一直存在。而且是强引用。这样 Entry中的 value对象就不能被回收了？
此时我们就可以手动回收value对象了。调用 ThreadLocal 的remove方法。

 public void remove() {//获取当前线程的ThreadLocalMap对象ThreadLocalMap m = getMap(Thread.currentThread());if (m != null)//调用ThreadLocalMap对象的remove方法m.remove(this);}

  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;}}}

其实ThreadLocal 里面的get/set 方法都会删除map 中key 为null的元素。这样可以尽最大努力避免内存泄露。

get 方法会调用 getEntryAfterMiss方法

     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)//如果key 是null. 删除该元素expungeStaleEntry(i);elsei = nextIndex(i, len);e = tab[i];}return null;}

set 方法会调用 set -->replaceStaleEntry–>cleanSomeSlots 方法

      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;}//key 为null.做删除操作if (k == null) {replaceStaleEntry(key, value, i);return;}}tab[i] = new Entry(key, value);int sz = ++size;if (!cleanSomeSlots(i, sz) && sz >= threshold)rehash();}

hash冲突解决

ThreadLocalMap 的冲突策略和HashMap不一样。HashMap 冲突后，是采用链表方式解决。ThreadLocalMap 如果发生冲突，则将元素放入下一个数组下标。如果超过了阈值，则进行扩容。

总结

ThreadLocal的逻辑不是特别复杂。但面试 问的特别多。希望本文能帮助到大家理解这块的逻辑。特别是涉及到内存泄露这块。