ThreadLocal 核心源码解析
1 前言
此类提供线程本地变量。这些变量与普通变量不一样，由于每一个访问一个变量（经过其get或set方法）的线程都有其本身的，独立初始化的变量副本。 ThreadLocal 实例一般是指望将状态与线程(例如，用户ID或事务ID)关联的类中的 private static 字段。java
例如，下面的类生成每一个线程本地的惟一标识符。线程的ID是在第一次调用ThreadId.get() 时赋值的，而且在之后的调用中保持不变。算法
2 继续体系
-
继承?不存在的,这其实也是 java.lang 包下的工具类 数组
图片标题 -
可是 ThreadLocal 定义带有泛型，说明能够储存任意格式的数据. 安全
图片标题
3 属性
-
ThreadLocal 依赖于附加到每一个线程（Thread.threadLocals和InheritableThreadLocals）的线程线性探测哈希表. ThreadLocal 对象充当键，经过 threadLocalHashCode 进行搜索。这是一个自定义哈希码(仅在ThreadLocalMaps 中有用)，它消除了在相同线程使用连续构造的threadlocal的常见状况下的冲突，而在不太常见的状况下仍然表现良好。 一句话总结: ThreadLocal 经过这样的 hashCode，计算当前 ThreadLocal 在 ThreadLocalMap 中的索引 数据结构
图片标题
图片标题 -
连续生成的哈希码之间的差值,关于该值的设定,可参考文章ThreadLocal的hash算法（关于 0x61c88647） 工具
图片标题 -
注意 static 修饰,ThreadLocalMap 会被 set 多个 ThreadLocal ，而多个 ThreadLocal 就根据 threadLocalHashCode 区分 post
图片标题
4 ThreadLocalMap
ThreadLocalMap 是自定义的哈希表，仅适用于维护线程本地的值。没有操做导出到ThreadLocal类以外。 该类是包私有的，容许在 Thread 类中的字段声明。为了帮助处理很是长的使用寿命，哈希表节点使用 WeakReferences 做为键。可是，因为不使用引用队列，所以仅在表空间不足时，才保证删除过期的节点。性能
static class ThreadLocalMap {
/** * 此哈希表中的节点使用其主引用字段做为键（始终是一个 ThreadLocal 对象） * 继承了 WeakReference。 * 请注意，空键（即entry.get（）== null）意味着再也不引用该键，所以能够从表中删除该节点。 * 在下面的代码中，此类节点称为 "stale entries" */
static class Entry extends WeakReference<ThreadLocal<?>> {
/** 与此 ThreadLocal 关联的值 */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
/** * 初始容量 -- 必须是 2 的幂 */
private static final int INITIAL_CAPACITY = 16;
/** * table 数组,必要时扩容 * table.length 必须是 2 的幂 */
private Entry[] table;
/** * table 中的节点个数 */
private int size = 0;
/** * 下一次扩容的阈值 */
private int threshold; // 默认为 0
复制代码
特色
- key 是 ThreadLocal 的引用
- value 是 ThreadLocal 保存的值
- 数组的数据结构
5 set
5.1 ThreadLocal#set
将此线程本地变量的当前线程副本设置为指定值。大多数子类将不须要重写此方法，而仅依靠initialValue方法来设置线程本地变量的值。this
执行流程
- 获取当前线程
- 获取线程所对应的ThreadLocalMap，从这能够看出每一个线程都是独立的,因此此方法自然线程安全
- 判断 map 是否为 null
- 否，则 K.V 对赋值，k 为this,即当前的 ThreaLocal 对象
- 是，则初始化一个 ThreadLocalMap 来维护 K.V 对
来具体看看ThreadLocalMap中的 setspa
5.2 ThreadLocalMap#set
private void set(ThreadLocal<?> key, Object value) {
// 新引用指向 table
Entry[] tab = table;
int len = tab.length;
// 获取对应 ThreadLocal 在table 中的索引,注意这里是 hashCode 与 2 幂次长度-1(想起来为何这样计算更好了吗?)
int i = key.threadLocalHashCode & (len-1);
/** * 从该下标开始循环遍历 * 一、如遇相同key，则直接替换value * 二、若是该key已经被回收失效，则替换该失效的key */
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 找到内存地址同样的 ThreadLocal，直接替换
if (k == key) {
e.value = value;
return;
}
// 若 k 为 null,说明 ThreadLocal 被清理了,则替换当前失效的 k
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 找到空位，建立节点并插入
tab[i] = new Entry(key, value);
// table内元素size自增
int sz = ++size;
// 达到阈值(数组大小的三分之二)时，执行扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
复制代码
注意经过 hashCode 计算的索引位置 i 处若是已经有值了，会从 i 开始，经过 +1 不断的日后寻找，直到找到索引位置为空的地方，把当前 ThreadLocal 做为 key 放进去。
6 get
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
// 获取当前线程对应的ThreadLocalMap
ThreadLocalMap map = getMap(t);
// 若是map不为空
if (map != null) {
// 取得当前ThreadLocal对象对应的Entry
ThreadLocalMap.Entry e = map.getEntry(this);
// 若是不为空，读取当前 ThreadLocal 中保存的值
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
// 不然都执行 setInitialValue
return setInitialValue();
}
复制代码
private T setInitialValue() {
// 获取初始值，通常是子类重写
T value = initialValue();
// 获取当前线程
Thread t = Thread.currentThread();
// 获取当前线程对应的ThreadLocalMap
ThreadLocalMap map = getMap(t);
// 若是map不为null
if (map != null)
// 调用ThreadLocalMap的set方法进行赋值
map.set(this, value);
// 不然建立个ThreadLocalMap进行赋值
else
createMap(t, value);
return value;
}
复制代码
接着咱们来看下
ThreadLocalMap#getEntry
// 获得当前 thradLocal 对应的值，值的类型是由 thradLocal 的泛型决定的
// 因为 thradLocalMap set 时解决数组索引位置冲突的逻辑，致使 thradLocalMap get 时的逻辑也是对应的
// 首先尝试根据 hashcode 取模数组大小-1 = 索引位置 i 寻找，找不到的话，自旋把 i+1，直到找到索引位置不为空为止
private Entry getEntry(ThreadLocal<?> key) {
// 计算索引位置：ThreadLocal 的 hashCode 取模数组大小-1
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
// e 不为空，而且 e 的 ThreadLocal 的内存地址和 key 相同，直接返回，不然就是没有找到，继续经过 getEntryAfterMiss 方法找
if (e != null && e.get() == key)
return e;
else
// 这个取数据的逻辑，是由于 set 时数组索引位置冲突形成的
return getEntryAfterMiss(key, i, e);
}
// 自旋 i+1，直到找到为止
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
// 在大量使用不一样 key 的 ThreadLocal 时，其实还蛮耗性能的
while (e != null) {
ThreadLocal<?> k = e.get();
// 内存地址同样，表示找到了
if (k == key)
return e;
// 删除没用的 key
if (k == null)
expungeStaleEntry(i);
// 继续使索引位置 + 1
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
复制代码
6 扩容
ThreadLocalMap 中的 ThreadLocal 的个数超过阈值时，ThreadLocalMap 就要开始扩容了，咱们一块儿来看下扩容的逻辑：
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 {
// 计算 ThreadLocal 在新数组中的位置
int h = k.threadLocalHashCode & (newLen - 1);
// 若是索引 h 的位置值不为空，日后+1，直到找到值为空的索引位置
while (newTab[h] != null)
h = nextIndex(h, newLen);
// 给新数组赋值
newTab[h] = e;
count++;
}
}
}
// 给新数组初始化下次扩容阈值，为数组长度的三分之二
setThreshold(newLen);
size = count;
table = newTab;
}
复制代码
源码注解也比较清晰，咱们注意两点：
扩容后数组大小是原来数组的两倍； 扩容时是绝对没有线程安全问题的，由于 ThreadLocalMap 是线程的一个属性，一个线程同一时刻只能对 ThreadLocalMap 进行操做，由于同一个线程执行业务逻辑必然是串行的，那么操做 ThreadLocalMap 必然也是串行的。
7 总结
ThreadLocal 是很是重要的 API，咱们在写一个中间件的时候常常会用到，好比说流程引擎中上下文的传递，调用链ID的传递等等，很是好用，但坑也不少。
- 1. ThreadLocal 源码解析
- 2. ThreadLocal源码解析
- 3. ThreadPoolExecutor 核心源码解析
- 4. CountDownLatch 核心源码解析
- 5. LinkedHashMap 核心源码解析
- 6. TreeSet 核心源码解析
- 7. Log4j源码解析--核心类解析
- 8. Java ThreadLocal源码解析: Thread和ThreadLocal
- 9. Spring源码解析 - springMVC核心代码
- 10. Java 8 ThreadLocal 源码解析
- 更多相关文章...
- • Hibernate的核心接口 - Hibernate教程
- • MyBatis的核心组件 - MyBatis教程
- • Scala 中文乱码解决
- • 互联网组织的未来：剖析GitHub员工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。