ThreadLocal源码解析

Java并发编程的学习过程当中，必定绕不过ThreadLocal，在实际开发中，ThreadLocal的应用场景仍是很丰富的：

1. 线程间数据的隔离。
2. Session的管理。
3. 事务的管理。
4. 参数的隐式传递(PageHelper)。
5. Dubbo的RpcContext。

为了更好的理解ThreadLocal原理，笔者记录一下源码阅读的过程，错误之处，还望读者指出，不胜感激。

---

源码解析

一、threadLocalHashCode ThreadLocal实例会被当作Key存放到Thread的ThreadLocalMap中，所以须要根据ThreadLocal的hashCode计算一个下标，还要解决哈希冲突等问题。ThreadLocalMap并非根据hashCode()方法来计算哈希值，而是用了一套递增的规则：

/* ThreadLocal实例会被当作Key存放到Thread的ThreadLocalMap中。 须要根据hashCode来计算下标。 这里并无调用hashCode()方法，而是根据0x61c88647的步长一直递增计算的。 */
private final int threadLocalHashCode = nextHashCode();

// 经过CAS的方式来生成hashCode
private static AtomicInteger nextHashCode =
		new AtomicInteger();

// hashCode递增的步长，为何是这个数？https://zhuanlan.zhihu.com/p/40515974
private static final int HASH_INCREMENT = 0x61c88647;

// 计算下一个hashCode，一直递增
private static int nextHashCode() {
	return nextHashCode.getAndAdd(HASH_INCREMENT);
}
复制代码

递增的步长为何是0x61c88647？ ThreadLocalMap底层是用Entry[]实现的，和HashMap同样，这个数组的长度无论如何扩容，始终都会是2的N次方，以0x61c88647为步长作递增，可让hashCode更加均匀的分布在2的N次方的数组里。具体能够参考：从 ThreadLocal 的实现看散列算法。

二、set()作了什么？ 当线程调用ThreadLocal的set()方法时，它首先会获取当前线程的ThreadLocalMap，若是为null，则建立一个ThreadLocalMap，不然往ThreadLocalMap里put元素。

/* 1.获取当前线程的ThreadLocalMap 2.为null则建立，并set 3.不为null则直接set */
public void set(T value) {
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null)
		map.set(this, value);
	else
		createMap(t, value);
}
复制代码

一个新的线程首次set()时，会建立一个ThreadLocalMap：

/* 给Thread的threadLocals建立Map实例，并添加元素。 */
void createMap(Thread t, T firstValue) {
	t.threadLocals = new ThreadLocalMap(this, firstValue);
}
复制代码

ThreadLocalMap ThreadLocalMap是ThreadLocal的静态内部类，底层采用Entry[]数组来保存数据。和HashMap不一样的是，遇到哈希冲突时，Entry并不会转换为链表或红黑树，而是采用开放定址法的线性探测来实现的。 关于哈希冲突的处理方式有哪些，能够看笔者的另外一篇文章：哈希冲突的常看法决方式。

// 初始化ThreadLocalMap实例
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
	// 初始化，默认容量16
	table = new Entry[INITIAL_CAPACITY];
	// 计算下标，算法：hashCode & (len - 1)，和HashMap同样，这里不详叙。
	int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
	table[i] = new Entry(firstKey, firstValue);
	size = 1;
	// 设置扩容阈值:容量的三分之二
	setThreshold(INITIAL_CAPACITY);
}

private void setThreshold(int len) {
	threshold = len * 2 / 3;
}
复制代码

Entry Entry继承自WeakReference，它的Key是一个弱引用，使用的时候须要注意，尽量的去手动执行remove()，以避免发生内存泄漏。

/* Entry的Key是弱引用。 当ThreadLocal实例外部不存在强引用时，GC就会将其回收掉。 若是没有调用remove()，value就仍然还有引用，无法回收。 这时就容易致使内存泄漏。 */
static class Entry extends WeakReference<ThreadLocal<?>> {
	Object value;

	Entry(ThreadLocal<?> k, Object v) {
		super(k);
		value = v;
	}
}
复制代码

若是ThreadLocalMap不为null时，则须要往里面添加元素了：

private void set(ThreadLocal<?> key, Object value) {
	Entry[] tab = table;
	int len = tab.length;
	// 计算下标，算法：hashCode & (len - 1)，和HashMap同样，这里不详叙。
	int i = key.threadLocalHashCode & (len-1);

	for (Entry e = tab[i];
		 /* 若是下标元素不是null，有两种状况: 1.同一个Key，覆盖value。 2.哈希冲突了。 */
		 e != null;
		 /* 哈希冲突的解决方式:开放定址法的线性探测。 当前下标被占用了，就找next，找到尾巴还没找到就从头开始找。 直到找到没有被占用的下标。 */
		 e = tab[i = nextIndex(i, len)]) {
		ThreadLocal<?> k = e.get();

		if (k == key) {
			// 相同的Key，则覆盖value。
			e.value = value;
			return;
		}

		if (k == null) {
			/* 下标被占用，可是Key.get()为null。说明ThreadLocal被回收了。 须要进行替换。 */
			replaceStaleEntry(key, value, i);
			return;
		}
	}

	tab[i] = new Entry(key, value);
	int sz = ++size;
	/* 1.判断是否能够清理一些槽位。 2.若是清理成功，就无需扩容了，由于已经腾出一些位置留给下次使用。 3.若是清理失败，则要判断是否须要扩容。 */
	if (!cleanSomeSlots(i, sz) && sz >= threshold)
		rehash();
}
复制代码

元素添加成功后，ThreadLocalMap会对元素中已经被回收的Key作清理工做。 处于性能考虑，ThreadLocalMap并不会对全部的元素进行检查，而是采样部分数据。

/* 清理部分槽位。 1.若是清理成功，就不用扩容了，由于已经腾出一部分位置了。 2.处于性能考虑，不会作全部元素作清理工做，而是采样清理。 set()时，n=size，搜索范围较小。 */
private boolean cleanSomeSlots(int i, int n) {
	boolean removed = false;
	Entry[] tab = table;
	int len = tab.length;
	do {
		i = nextIndex(i, len);
		Entry e = tab[i];
		if (e != null && e.get() == null) {
			// 一旦搜索到了过时元素，则n=len，扩大搜索范围
			n = len;
			removed = true;
			// 真正清理的逻辑
			i = expungeStaleEntry(i);
		}
		/* 采样规则: n >>>= 1 (折半) 例:100 > 50 > 25 > 12 > 6 > 3 > 1 */
	} while ( (n >>>= 1) != 0);
	return removed;
}
复制代码

若是找到了过时的Key，那就要进行清理工做了：

/* 删除过时的元素:占用下标，可是ThreadLocal实例已经被回收的元素。 */
private int expungeStaleEntry(int staleSlot) {
	Entry[] tab = table;
	int len = tab.length;

	// 清理当前Entry
	tab[staleSlot].value = null;
	tab[staleSlot] = null;
	size--;

	// Rehash until we encounter null
	Entry e;
	int i;
	// 继续日后寻找，直到遇到null结束
	for (i = nextIndex(staleSlot, len);
		 (e = tab[i]) != null;
		 i = nextIndex(i, len)) {
		ThreadLocal<?> k = e.get();
		if (k == null) {
			// 再次发现过时元素，清理掉
			e.value = null;
			tab[i] = null;
			size--;
		} else {
			// 处理从新哈希的逻辑
			int h = k.threadLocalHashCode & (len - 1);
			if (h != i) {
				tab[i] = null;

				// Unlike Knuth 6.4 Algorithm R, we must scan until
				// null because multiple entries could have been stale.
				while (tab[h] != null)
					h = nextIndex(h, len);
				tab[h] = e;
			}
		}
	}
	return i;
}
复制代码

清理时，并非只清理掉当前Entry就结束了，而是会日后环形的继续寻找过时的Entry，只要找到了就清理，直到遇到tab[i]==null就结束，清理的过程当中还会对元素作一个rehash的操做。

若是清理不成功，则要判断size是否超过threshold阈值，若是超过，则要进行全量的清理工做和判断是否扩容。

private void rehash() {
	// 全量清理过时Entry
	expungeStaleEntries();

	// 清理后，若是size依然超过阈值的四分之三，则要扩容
	if (size >= threshold - threshold / 4)
		resize();
}
复制代码

全量清理过时Entry：

// 全量清理过时Entry
private void expungeStaleEntries() {
	Entry[] tab = table;
	int len = tab.length;
	for (int j = 0; j < len; j++) {
		Entry e = tab[j];
		// 遍历数组，找到过时元素就清理
		if (e != null && e.get() == null)
			expungeStaleEntry(j);
	}
}
复制代码

清理后，若是size依然超过阈值的四分之三，则要扩容：

// 扩容规则:双倍扩容
private void resize() {
	Entry[] oldTab = table;
	int oldLen = oldTab.length;
	int newLen = oldLen * 2;
	Entry[] newTab = new Entry[newLen];
	int count = 0;

	for (int j = 0; j < oldLen; ++j) {
		Entry e = oldTab[j];
		if (e != null) {
			ThreadLocal<?> k = e.get();
			if (k == null) {
				// 扩容期间发现过时元素，会跳过
				e.value = null; // Help the GC
			} else {
				// 将旧数组中没有过时的元素挪到新数组里
				int h = k.threadLocalHashCode & (newLen - 1);
				while (newTab[h] != null)
					h = nextIndex(h, newLen);
				newTab[h] = e;
				count++;
			}
		}
	}
	// 从新设置阈值
	setThreshold(newLen);
	size = count;
	table = newTab;
}
复制代码

至此，Set()的逻辑所有结束。

三、get()作了什么？ get()获取Value时，首先会判断当前线程的ThreadLocalMap是否为null，若是为null，则会调用initialValue()得到一个初始值，并set()到ThreadLocalMap中。

/* 获取Value时: 1.获取当前线程的ThreadLocalMap 2.若是为null，则建立Map并设置初始值。 3.不为null，则经过Map查找。 */
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();
}
复制代码

若是ThreadLocalMap不为null，则要开始查找了：

/* 经过Key获取Entry */
private Entry getEntry(ThreadLocal<?> key) {
	// 计算下标
	int i = key.threadLocalHashCode & (table.length - 1);
	Entry e = table[i];
	if (e != null && e.get() == key) {
		// 若是对应下标节点不为null，且Key相等，则命中直接返回
		return e;
	} else {
		/* 不然有两种状况: 1.Key不存在。 2.哈希冲突了，须要向后环形查找。 */
		return getEntryAfterMiss(key, i, e);
	}
}
复制代码

命中则直接返回，不命中有两种状况:

1. Key不存在。
2. 哈希冲突了，须要向后环形查找。

/* 没法直接命中的查找逻辑 */
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
	Entry[] tab = table;
	int len = tab.length;

	while (e != null) {// e==null说明Key不存在，直接返回null
		ThreadLocal<?> k = e.get();
		if (k == key)
			// 找到了，说明是哈希冲突
			return e;
		if (k == null)
			// Key存在，可是过时了，须要清理掉，而且返回null
			expungeStaleEntry(i);
		else
			// 向后环形查找
			i = nextIndex(i, len);
		e = tab[i];
	}
	return null;
}
复制代码

若是成功找到了Entry节点，则直接返回其value便可。

三、remove()作了什么？ 获取当前线程的ThreadLocalMap，并删除元素。

// 找到当前线程的ThreadLocalMap，并删除元素
public void remove() {
	ThreadLocalMap m = getMap(Thread.currentThread());
	if (m != null)
		m.remove(this);
}
复制代码

主要逻辑在ThreadLocalMap.remove()里：

// 经过Key删除Entry
private void remove(ThreadLocal<?> key) {
	Entry[] tab = table;
	int len = tab.length;
	// 计算下标
	int i = key.threadLocalHashCode & (len-1);
	/* 删除也是同样，因为存在哈希冲突，不能直接定位到下标后直接删除。 删除前须要确认Key是否相等，若是不等须要日后环形查找。 */
	for (Entry e = tab[i];
		 e != null;
		 e = tab[i = nextIndex(i, len)]) {
		if (e.get() == key) {
			/* 找到了就清理掉。 这里并无直接清理，而是将Key的Reference引用清空了， 而后再调用expungeStaleEntry()清理过时元素。 顺便还能够清理后续节点。 */
			e.clear();
			expungeStaleEntry(i);
			return;
		}
	}
}
复制代码

因为哈希冲突的存在，因此不能定位到节点后直接删除，须要确认Key是否相等，若是不等须要日后环形查找，直到找到正确的Key。

清理也不是简单的直接置空，而是先将Key的引用置空，而后调用了expungeStaleEntry()方法清理过时的元素。这个过程会顺带清理后续的节点和rehash操做。

---

问题

一、为何要使用弱引用？

每一个线程都有本身的ThreadLocalMap，若是ThreadLocalMap强引用了ThreadLocal，那么即便咱们执行了ThreadLocal=null，ThreadLocal也没法被回收，难道你想回收ThreadLocal时，遍历全部线程，将全部线程的ThreadLocalMap的当前ThreadLocal进行remove操做？？？

正是因为采用了弱引用，这才使得，只要ThreadLocal实例外部不存在强引用，GC时就能将其回收，ThreadLocalMap在进行一些读写操做时，也会去自发性的作一些过时检查，删除过时的Entry，最大程度的避免了内存泄漏。

二、为何会内存泄漏？

ThreadLocalMap的弱引用只针对Key，若是ThreadLocal不存在强引用了，GC就会将其回收，可是Value因为存在和Entry的强引用，所以不会被回收，这样就会致使一些永远也没法被访问的Value存在，即发生内存泄漏。

固然，针对这种状况，JDK已经在尽可能去避免了。在对ThreadLocal进行读写时，有不少地方会触发它执行过时检查，删除过时的Entry，避免内存泄漏。

三、何时会触发过时检查清理？

1. 调用set()方法时，采样清理、全量清理，扩容时还会继续检查。
2. 调用get()方法，没有直接命中，向后环形查找时。
3. 调用remove()时，除了清理当前Entry，还会向后继续清理。

四、如何避免内存泄漏

使用ThreadLocal时，通常建议将其声明为static final的，避免频繁建立ThreadLocal实例。尽可能避免存储大对象，若是非要存，那么尽可能在访问完成后及时调用remove()删除掉。

ThreadLocal的Value会发生内存泄漏的状况，可是JDK已经作了不少操做来避免。例如上面说的会在不少场景下自发的去清理过时的Entry，使得无效Value能够被回收。通常来讲正常使用不会有太大的问题，可能会致使部分Value会发生短暂的内存泄漏，可是在后续的过时检查中，也是会被清理掉的。 尽管如此，仍是建议你们及时调用remove()。

---

你可能感兴趣的文章：

• AQS源码导读
• 摊牌了，我要手写一个RPC
• Java锁的膨胀过程以及一致性哈希对锁膨胀的影响
• CMS与三色标记算法
• 大白话理解可达性分析算法