ThreadLocal 原理及源码详解

什么是ThreadLocal？

ThreadLocal 是一种提供线程本地变量（也称为线程局部变量）的类，这种变量确保了在不同的线程中访问同一个 ThreadLocal 变量时，每个线程会有一个该变量的私有副本，即使多个线程修改了相同的 ThreadLocal 变量，每个线程所访问的副本仍然是独立的，从而避免了多线程环境下共享变量可能导致的数据不一致和竞争问题。

ThreadLocal 知识储备传送门：

ThreadLocal 实战使用详解

ThreadLocal 内存泄漏和常见问题详解

ThreadLocal 常用方法：

• ThreadLocal #ThreadLocal()：ThreadLocal 构造方法。
• ThreadLocal #set(T value)：设置当前线程绑定的局部变量。
• ThreadLocal #get()：获取当前线程绑定的局部变量。
• ThreadLocal #remove()：移出当前线程绑定的局部变量，防止内存泄漏。
• ThreadLocal #initialValue()：返回当前线程局部变量的初始值。

ThreadLocal 源码分析

ThreadLocal 内部结构：

• 我们知道 ThreadLocal 是线程本地变量，那 ThreadLocal 肯定是线程的一个属性。
• ThredLocal 类的内部有一个 ThreadLocalMap 的内部类，来帮我们进行的数据的存储。
• ThreadLocalMap 的 key 是 ThreadLocal，value 是我们要操作的 value 值，我们可以把 ThreadLocalMap 理解为操作 ThreadLocal 的工具类。

我们知道 ThreadLocal 是属于 Thread 的，以下代码是摘自 Thread 源码中的一段：

class Thread implements Runnable {

    //与线程相关的 ThreadLocal值，此Map由 ThreadLocal 类维护
    ThreadLocal.ThreadLocalMap threadLocals = null;

    //与线程相关的InheritableThreadLocal 值。此Map 由 InheritableThreadLocal 类维护(子线程相关的 本次不讨论) 
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
}

可以看到我们本篇讨论的 ThreadLocal 出现了，其出现的地方是 Thread 类中，是 Thread 类的一个变量，ThreadLocal 出现的同时，我们发现了 ThreadLocalMap 的存在，根据 ThreadLocal.ThreadLocalMap 我们知道 ThreadLocalMap 是 ThreadLocal 的一个内部类，我们接着追踪一下 ThreadLocal 源码。

ThreadLocalMap#set(T value) 方法源码分析：

//往ThreadLocalMap 中设置 ThreadLocal 和 value 的关系
private void set(ThreadLocal<?> key, Object value) {
	//Entry 数组
	Entry[] tab = table;
	//获取数组的长度
	int len = tab.length;
	//返回下一个hashcode
	int i = key.threadLocalHashCode & (len-1);

	//遍历数组
	for (Entry e = tab[i];
		 e != null;
		 e = tab[i = nextIndex(i, len)]) {
		//获取key ThreadLocal
		ThreadLocal<?> k = e.get();
		//判断是否是当前key
		if (k == key) {
			//替换 value  返回
			e.value = value;
			return;
		}
		//key 为空
		if (k == null) {
			//key 为null 时候 清理过期的 entry 有助于 JVM GC
			replaceStaleEntry(key, value, i);
			return;
		}
	}
	
	//创建一个 entry 节点
	tab[i] = new Entry(key, value);
	//size 加1
	int sz = ++size;
	//是否大于等于负载因子 大于等于则需要扩容
	if (!cleanSomeSlots(i, sz) && sz >= threshold)
		//扩容
		rehash();
}

ThreadLocalMap#replaceStaleEntry 方法源码分析：

//把key value 设置到 staleSlot位置上 这里的key 为null
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
							   int staleSlot) {
	//获取当前	Entry 数组						   
	Entry[] tab = table;
	//数组长度
	int len = tab.length;
	//entry
	Entry e;


	int slotToExpunge = staleSlot;
	//从staleSlot 往前找entry 直到 (e = tab[i]) == null 结束
	for (int i = prevIndex(staleSlot, len);
		 (e = tab[i]) != null;
		 i = prevIndex(i, len))
		 //key为空 找到了需要废弃的位置了
		if (e.get() == null)
			slotToExpunge = i;

	从staleSlot 往后找entry 直到 (e = tab[i]) == null 结束
	for (int i = nextIndex(staleSlot, len);
		 (e = tab[i]) != null;
		 i = nextIndex(i, len)) {
		//(e = tab[i]) != null
		//获取key 
		ThreadLocal<?> k = e.get();

		//找到了自己 e 就是自己 e 的key 为 null  value 不为 null 
		if (k == key) {
			//替换 value 
			e.value = value;
			//交换 staleSlot 和 i 位置的 entry i 位置的entry 是 e 也是脏 entry 也是传过来的entry
			tab[i] = tab[staleSlot];
			//把当 entry e 也就是当前传过来的无效的脏的 entry的 key value 替换到 staleSlot 位置上 i 位置现在是个脏的无效的 entry
			tab[staleSlot] = e;
			
			if (slotToExpunge == staleSlot)
				//等于 表示 之前没有被改变过 也就是往前找 没有找到 方法入参 key 对应的entry 
				//因为当前遍历是从 staleSlot向后遍历 因此 i 大于 staleSlot   i 位置现在是个脏的无效的 entry 需求被清理掉 
				//赋值为 i 从i 的位置开始清理无效的脏的entry
				slotToExpunge = i;
			//遍历清除 脏的 也就是无效的 entry  expungeStaleEntry 方法 从 i 开始往后清理 无效的脏的 entry 
			cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
			return;
		}

		//key == null 表示找到了无效的数据 
		//如果此时 slotToExpunge 还是等于 staleSlot 说明在向前的循环中没有出现过期数据
		//i 赋值给 slotToExpunge
		if (k == null && slotToExpunge == staleSlot)
			slotToExpunge = i;
	}

	//走到这里表示没有清理无效的 脏的entry 设置 就直接设置  staleSlot 位置value 为空
	tab[staleSlot].value = null;
	//然后直接在把无效数据设置到 staleSlot 位置上 等待清理
	tab[staleSlot] = new Entry(key, value);
	
	//如果slotToExpunge == staleSlot 表示除了 staleSlot 位置上是过期数据之外 向前向后都没有找到过期数据
	//slotToExpunge 不等于 staleSlot 表示还有无效数据要清理
	if (slotToExpunge != staleSlot)
		cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

ThreadLocalMap#expungeStaleEntry方法源码分析：

//从staleSlot位置开始往后找entry 遇到entry key为null 的设置其value 也为null 直到遇到entry 为null 结束 
private int expungeStaleEntry(int staleSlot) {
	//获取entry 数组
	Entry[] tab = table;
	//获取数组的长度
	int len = tab.length;

	// expunge entry at staleSlot
	//设置 staleSlot 位置的entry key 和value 都为 null 方便 JVM GC
	tab[staleSlot].value = null;
	tab[staleSlot] = null;
	//entry 数组长度-1
	size--;

	// Rehash until we encounter null
	Entry e;
	int i;
	//rehash 操作  (e = tab[i]) != null 才会继续循环 也就是 (e = tab[i]) == null 结束
	for (i = nextIndex(staleSlot, len);
		 (e = tab[i]) != null;
		 i = nextIndex(i, len)) {
		//获取entry 的key 也就是 ThreadLocal
		ThreadLocal<?> k = e.get();
		if (k == null) {
			//key 为 null 设置 value 也为 null
			e.value = null;
			tab[i] = null;
			//entry 数组长度-1
			size--;
		} else {
			//获取key 在数组中的位置
			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.
				//key 所在的位置不为空
				while (tab[h] != null)
					//递增找下一个为空的位置
					h = nextIndex(h, len);
				//为空  设置为 e
				tab[h] = e;
			}
		}
	}
	return i;
}

ThreadLocal #get() 源码分析：

get 方法逻辑很简单，就是获取当前线程绑定的局部变量。

//获取当前线程的局部变量
public T get() {
	//获取当前线程
	Thread t = Thread.currentThread();
	//获取当前线程的 ThreadLocalMap
	ThreadLocalMap map = getMap(t);
	if (map != null) {
		//map 不为空 获取当前 ThreadLocal 对应的 entry
		ThreadLocalMap.Entry e = map.getEntry(this);
		if (e != null) {
			@SuppressWarnings("unchecked")
			//获取value
			T result = (T)e.value;
			return result;
		}
	}
	//map 为空 创建一个map 设置初始值为 null 就是初始化操作
	return setInitialValue();
}

ThreadLocal #remove() 源码分析：

remove 方法就是移出当前线程绑定的局部变量，防止内存泄漏。

//删除当前线程的局部变量
//删除当前线程的局部变量
public void remove() {
	 //获取当前线程的 ThreadLocalMap
	 ThreadLocalMap m = getMap(Thread.currentThread());
	 if (m != null)
		 //不为空 执行删除操作
		 m.remove(this);
}

//根据 key 删除 entry
private void remove(ThreadLocal<?> key) {
	//entry 数组
	Entry[] tab = table;
	//数组的长度
	int len = tab.length;
	//找到 key 在entry 数组中的位置
	int i = key.threadLocalHashCode & (len-1);
	for (Entry e = tab[i];
		 e != null;
		 e = tab[i = nextIndex(i, len)]) {
		if (e.get() == key) {
			//找到key 删除掉 clear 方法其实就是赋值为 null 方便 JVM 回收
			e.clear();
			//清理无效的 entry 上面set 方法中有分析
			expungeStaleEntry(i);
			return;
		}
	}
}

ThreadLocal #cleanSomeSlots() 源码分析：

//清除无效数据
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;
			removed = true;
			//清理过期数据
			i = expungeStaleEntry(i);
		}
	} while ( (n >>>= 1) != 0);
	return removed;
}

关于 ThreadLocal 的源码解析就分享到这里，本篇主要是对 ThreadLocal 的源码进行了分析，后面会接着分享 ThreadLocal 的使用及常用问题，希望可以帮助到有需要的伙伴。

欢迎提出建议及对错误的地方指出纠正。