本文详细分析了Java中的ThreadLocal类，包括其数据结构、set、get和remove方法的源码，以及InheritableThreadLocal的特性。ThreadLocal通过在每个线程中存储独立副本，实现线程局部变量。文章还探讨了其在内存管理和线程间数据隔离中的关键作用，并提供了实例来帮助理解。
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
ThreadLocal 是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其他线程来说则无法获取到数据。
虽然在不同线程中访问的是同一个 ThreadLocal 对象，但是它们通过 ThreadLocal 获取到的值却是不一样的。
一般来说，当某些数据是以线程为作用域并且不同线程具有不同的数据副本的时候，就可以考虑采用 ThreadLocal。
本段内容出自《Android 开发艺术探索》
一、数据结构
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal 是对 Thread 中的全局变量，类型是 ThreadLocal.ThreadLocalMap 的threadLocals 的封装，它使用哈希表的方式来存储数据但是并没有实现 Map 接口，它维护了一个 Entry 数组，Entry 继承自 WeakReference 传入的泛型类型是 ThreadLocal，弱引用表示只要发生垃圾回收，若这个对象只被弱引用指向，那么就会被回收
ThreadLocalMap 使用的解决哈希冲突的方式是开放定址法，开放定址法是指当发生地址冲突时，按照某种方法继续探测哈希表中的其他存储单元，直到找到空位置为止
二、源码分析
1. set
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// INITIAL_CAPACITY 默认容量是 16
table = new Entry[INITIAL_CAPACITY];
// 相当于 firstKey.threadLocalHashCode 对 16 求模运算得到 value 应该存储的索引位置
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
拿到当前线程的 threadLocals 如果为空则创建 ThreadLocalMap 对象并且在构造方法中把要存储的 value 存储到指定位置。threadLocalHashCode 是 ThreadLocal 创建时计算的一个哈希值
public class ThreadLocal<T> {
private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode =
new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
每次自增 HASH_INCREMENT 作用是使 ThreadLocal 尽量均匀的分布在哈希表中，下面主要看一下当 map 不为空时调用的 set 方法
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 计算 value 在数组 tab 中应该存储的下标位置
int i = key.threadLocalHashCode & (len-1);
// 如果指定位置已经有数据了说明存在哈希冲突则依次往后遍历（开放定址法）
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 如果 key 相等则替换流程结束
if (k == key) {
e.value = value;
return;
}
// 如果 key 为 null 说明发生了 GC 被回收了则替换此位置的值
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 如果指定位置的值为 null 说明没有哈希冲突创建 Entry 对象存入指定位置
tab[i] = new Entry(key, value);
int sz = ++size;
// 如果没有因为回收而被清除的位置并且存储的数据个数等于扩容阈值则尝试扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
上面注释已经比较清楚了，看下 replaceStaleEntry
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// slotToExpunge 用于记录数组中最前方 key 被回收的索引位置
int slotToExpunge = staleSlot;
// 从当前 key 被垃圾回收了的位置向前遍历直到 entry 为 null
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
// 如果 key 被回收了就记录位置
if (e.get() == null)
slotToExpunge = i;
// 从当前 key 被垃圾回收了的位置向后遍历
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// 如果一个 key 被回收了的 entry 位置后的 key 与要存储的数据 key 相等则替换
if (k == key) {
e.value = value;
// 替换索引 i 和索引 staleSlot 两处的值
// staleSlot 位置是一个 key 被回收了的陈旧 Entry
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// 如果上面向前遍历的过程中没有发现 key 被回收了的陈旧 Entry
// 则把 slotToExpunge 记录为当前位置然后从记录的位置开始清理并返回
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
// 如果上面向前遍历的过程中没有发现 key 被回收了的陈旧 Entry
// 并且向后遍历的过程中又发现了 key 被回收了的陈旧 Entry
// 则再第一次满足条件时记录此位置
// 记录当前位置而不是 staleSlot 是因为下面会把要存储的值
// 存储到 staleSlot 位置
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// 将要存储的数据存储到 staleSlot 位置
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// 如果遍历过程中发现了陈旧的 Entry 则执行清理
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
expungeStaleEntry 与 cleanSomeSlots 都是对数组中的数据进行清理 expungeStaleEntry 是探测式清理 cleanSomeSlots 是启发式清理，先看下 expungeStaleEntry
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 将 key 已经被回收了的陈旧位置置为 null
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
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) {
// 如果 key 已经被回收了则置空
e.value = null;
tab[i] = null;
size--;
} else {
// 如果计算到的 key 应该存储的位置与当前位置不一致
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
// 把当前位置的值置空
tab[i] = null;
// 从应该存储的位置依次找第一个数据为空的位置存入
// 让数据存储在它应该存储的位置
// 如果有哈希冲突就继续往后找
// 保证元素的存储是在应该存储的位置后是连续的
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
expungeStaleEntry 会返回一个值为 null 的索引位置作为 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) {
// 找到 key 被回收了的 entry 重置 n 的值为数组的长度
n = len;
// 记录有元素被清理了
removed = true;
// 真正的清理工作还是 expungeStaleEntry 来做的
i = expungeStaleEntry(i);
}
// 相当于 n = n / 2
// 这里遍历结束的条件不是遇见 null 而是 n = 0
} while ( (n >>>= 1) != 0);
return removed;
}
在上面的 java.lang.ThreadLocal.ThreadLocalMap#set 方法中的最后，如果没有陈旧元素被清理并且容量满了则执行扩容
private void rehash() {
expungeStaleEntries();
// 如果清理后数组中的元素超出数组大小的 3/4 则扩容
if (size >= threshold - threshold / 4)
resize();
}
// 重新扫描整个数组如果有陈旧的元素则清理
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);
}
}
所以扩容的整体逻辑是，在存储元素的时候存储到了数组中一个空的位置，先从插入位置的下一个位置往后进行清理，清理后过程没有发现成就元素并且数组满了，再对整个数组从头进行清理，清理后如果存储的数据个数大于数组容量的 3/4 则执行真正的扩容逻辑
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
// 扩容为元数组容量的 2 倍
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();
// 如果 key 已经被回收了置空
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 方法的全部内容覆盖了 ThreadLocal 大部分内容，因为 key 是弱引用做了很多 key 被垃圾回收后的清理工作，下面看一下 get 的内容
2. get
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;
}
}
// 如果 map 为 null 执行初始化的逻辑
return setInitialValue();
}
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
// 初始化当前线程的 threadLocals 存入初始值
createMap(t, value);
return value;
}
map 或者 map.getEntry(this) 为 null 的逻辑比较简单主要看下 map.getEntry(this) 不为 null 的部分
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
// 如果应该存储的位置的 entry.key == key 则返回 entry
if (e != null && e.get() == key)
return e;
else
// entry.key != key 的情况说明有哈希冲突继续往后查找
return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal<?> k = e.get();
// 找到了指定的 key 返回
if (k == key)
return e;
// 当前位置的 key 已经被回收则清理
// 让哈希值相等的 ThreadLocal 在数组中的存储是连续的
// 这样才能保证可以遇见 null 退出循环
if (k == null)
expungeStaleEntry(i);
else
// 继续比较下一个位置
i = nextIndex(i, len);
e = tab[i];
}
// 找不到返回 null
return null;
}
get 相对于 set 相对简单，只有涉及到探测式清理不涉及启发式清理和扩容部分
3. remove
一个好的使用习惯是在使用完之后调用 remove 避免内存泄漏
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
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 然后执行弱引用的 clear 执行清理工作
4. InheritableThreadLocal
InheritableThreadLocal 是 ThreadLocal 的子类，它可以使子线程创建它的父线程里的数据，实现是在创建线程的 init 方法中会判断如果父线程的 inheritableThreadLocals 不为空则复制到自己的 inheritableThreadLocals 中
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
this.name = name;
Thread parent = currentThread();
setPriority(priority);
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
}
总结
分析源码的时候画图更容易理解就是画图太费时间了
以上就是 ThreadLocal 的所有内容
如果错误请指正
参考
这些文章都比本文写得好：
面试官：小伙子，听说你看过ThreadLocal源码？（万字图文深度解析ThreadLocal）
被大厂面试官连环炮轰炸的ThreadLocal （吃透源码的每一个细节和设计原理）
ThreadLocal工作原理
《Android 开发艺术探索》
扫一扫
1076
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
