Java ThreadLocal解析

ThreadLocal 线程本地变量, 线程私有, 在 Thread 类中用 ThreadLocal.ThreadLocalMap threadLocals 以数组的形式存储. 因为是线程私有的变量, 所以不会有多线程访问的线程安全问题, 下面就对它开始解析(JDK1.8 的 ThreadLocal).

threadLocalHashCode

在说 ThreadLocal 的使用之前, 先说一个比较重要的东西, 就是 threadLocalHashCode, 这个hashCode 的值用来计算 当前 ThreadLocal 应当位于 ThreadLocalMap 的数组中的下标, 为什么是应当呢, 请往下看

    // ThreadLocalHashCode 递增值private static final int HASH_INCREMENT = 0x61c88647;/*** Returns the next hash code.*/private static int nextHashCode() {return nextHashCode.getAndAdd(HASH_INCREMENT);}// 每个 ThreadLocal 的 threadLocalHashCode 通过一个静态的原子变量递增而获得private final int threadLocalHashCode = nextHashCode();

ThreadLocal#set 方法

一个 ThreadLocalMap 可以存储多个 ThreadLocal 变量, 存取的时候将 ThreadLocal 作为key 放入 Entry 中, ThreadLocalMap 存储数据的对象为 Entry[], 计算 key 所属的下标用 int i = key.threadLocalHashCode & (len-1) 计算, 如果该下标已有数据, 根据 key(ThreadLocal变量) 判断是否属于这个 ThreadLocal, 不是同一个 ThreadLocal 则按顺序往后查找为空(或者 ThreadLocal 已经被GC回收)的 Entry设置 value.下面是 set方法的比较重要的部分源代码:

    // 最开始计算的下标iint i = key.threadLocalHashCode & (len-1);// 从计算出来的数组中的第 i 个开始往后找, i > len-1 的时候就从0开始for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {// nextIndex(i,len): ((i + 1 < len) ? i + 1 : 0); i+1>=len则从下标0开始ThreadLocal<?> k = e.get();// 根据 key 判断是否为当前的 ThreadLocalif (k == key) {e.value = value;return;}// Entry 的 key 为空, 但是上面循环的判断是 Entry 不为空, 表明作为 Entry 的 key的 ThreadLocal 已经被 GC 回收, 所以此时设置新的 key(ThreadLocal) 和 value.if (k == null) {// 替换掉旧的 ThreadLocalreplaceStaleEntry(key, value, i);return;}// 已经找到为空的 Entry, 直接 new 一个 Entrytab[i] = new Entry(key, value);int sz = ++size;if (!cleanSomeSlots(i, sz) && sz >= threshold)// 扩容将所有的 Entry 重新设置rehash();}

ThreadLocal#get 方法

get 方法跟 set 方法还是有挺多相同处的, 看代码

    private Entry getEntry(ThreadLocal<?> key) {// 计算下标int i = key.threadLocalHashCode & (table.length - 1);Entry e = table[i];// 如果对应下标的 Entry 属于当前 ThreadLocal 的话, 直接返回结果if (e != null && e.get() == key)return e;else// 会到这里的原因是因为 set 的时候的 hash 冲突, 冲突后会往后查找(超过len-1则从0开始)可以放置的位置, 所以前面初始化 hashCode 的时候是用的应当位于的位置return getEntryAfterMiss(key, i, e);}// e 为应当属于它的 Entryprivate Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {Entry[] tab = table;int len = tab.length;// while (e != null) {ThreadLocal<?> k = e.get();// 查找到属于自己的 valueif (k == key)return e;// 如果在查找的时候发现有的 Entry 的 key(ThreadLocal) 已经被 GC 回收, 则进行回收if (k == null)expungeStaleEntry(i);else// 往后查找, 超过 len-1 则从 0 开始继续i = nextIndex(i, len);e = tab[i];}return null;}

关于ThreadLocal 的 WeakReference

在说 ThreadLocal 的 WeakReference 之前, 先简单介绍一下 WeakReference .

WeakReference

弱引用不同于 java 中用 new创建(强引用) 的对象, 当对象只有弱引用(weakReference) 的时候, 进行GC的时候, 会对其进行回收(没有强引用的对象均会被gc回收)

    Object o = new Object();WeakReference weakReference = new WeakReference(o);System.out.println("beforeGC: "+weakReference.get());o = null;System.gc();System.out.println("afterGC: "+weakReference.get());Object o2 = new Object();WeakReference weakReference2 = new WeakReference(o2);System.out.println("beforeGC2: "+weakReference2.get());System.gc();System.out.println("afterGC2: "+weakReference2.get());

输出结果是:

beforeGC: java.lang.Object@5e2de80c
afterGC: null
beforeGC: java.lang.Object@1d44bcfa
afterGC: java.lang.Object@1d44bcfa

从这里可以看出, 即使有 weakFerence 弱引用, 也不能阻止对象被 GC 回收掉(因为它很弱啊哈哈).

ThreadLocal 中使用的 WeakReference

从上面set的方法看到了一行 tab[i] = new Entry(key, value)

Entry 是一个静态类

    // Entry 继承 WeakReference, 多了个 value 记录 ThreadLocal 的值static class Entry extends WeakReference<ThreadLocal<?>> {// 这个值就是 ThreadLocal set 进来的值Object value;Entry(ThreadLocal<?> k, Object v) {// 将 ThreadLocal 设置为引用对象super(k);value = v;}}

super(k)就是将 ThreadLocal 设置为引用对象, 获取的时候,调用父类的get方法, entry.get() --> 返回的就是引用的对象(这里就是 ThreadLocal)

    // super(k)Reference(T referent) {this(referent, null);}// set referenceReference(T referent, ReferenceQueue<? super T> queue) {this.referent = referent;this.queue = (queue == null) ? ReferenceQueue.NULL : queue;}// getpublic T get() {return this.referent;}

代码看起来难度不大, 下面说一下 JDK 的 ThreadLocal 使用不当会导致内存泄漏的问题.

在上面的 set 和 get 方法中, 有这么(类似)一段代码:

    for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {// nextIndex(i,len): ((i + 1 < len) ? i + 1 : 0); i+1>=len则从下标0开始ThreadLocal<?> k = e.get();// 根据 key 判断是否为当前的 ThreadLocalif (k == key) {e.value = value;return;}// Entry 的 key 为空, 但是上面循环的判断是 Entry 不为空, 表明作为 Entry 的 key的 ThreadLocal 已经被 GC 回收, 所以此时设置新的 key(ThreadLocal) 和 value.if (k == null) {// 替换掉旧的 ThreadLocalreplaceStaleEntry(key, value, i);return;}

if(k == null) 这里, 加上外层循环就是 if(e!=null && k == null), Entry不为空表明之前设置过 ThreadLocal 的值, 但是 k(key)==null 也就是 ThreadLocal == null, 为什么ThreadLocal 会为空? 前面我们说到 Entry 里面对 ThreadLocal(key) 是使用的 弱引用 , 也就是 Entry 持有 ThreadLocal 的引用并不会阻止GC 将 ThreadLocal 回收掉, 如果 ThreadLocal 手动置为 null , 则失去了强引用, 若其他地方没有这个 ThreadLocal 的强引用, 这个ThreadLocal 将会被GC回收掉, 此时 Entry 里面的 key == null, 但是 Entry 对 value 是强引用, 所以 value 不会被GC回收掉, 此时就造成了 Entry 的 key==null 但是 value !=null, 如果没有其它的 ThreadLocal 被设置进(或者get)同一个 Entry 的话, 这个 Entry 将会一直持有无用的 value, 造成内存泄漏, 泄漏的过多最终会导致 OOM.

解决办法呢就是在 ThreadLocal 置为 null之前, 先调用 remove 方法:

    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)]) {// 找到与自己匹配的 Entryif (e.get() == key) {e.clear();// 这个方法名也说的很清楚了, 删掉陈旧的 EntryexpungeStaleEntry(i);return;}}}

所以使用 JDK 的 ThreadLocal , 在不需要的时候需要手动调用 remove() 方法, 防止导致内存泄漏, 最终导致 OOM.