TreadLocal阅读笔记
文章目录
二、类结构
ThreadLocal
中嵌套内部类ThreadLocalMap
,这个类本质上是一个Map,和HashMap之类的实现相似,依然是key-value的形式,其中有一个内部类Entry
,其中key可以看做是ThreadLocal实例,但是本质是持有ThreadLocal实例的弱引用。
三、存储结构
- 每个Thread线程内部都有一个Map
- Map里面存储线程本地对象(key)和线程的变量副本(value)
- 但是Thread内部的Map是由ThreadLocal维护的,由ThreadLocal负责向Map获取和设置线程的副本变量值
- 所以对于不通的线程,每次获取副本值时,别的线程并不能获取到当前线程的副本之,形成了副本的隔离,互不干扰
四、源码分析
内部类
ThreadLocalMap
1、ThreadLocalMap内部类-属性
-
// 默认容量大小-16 private static final int INITIAL_CAPACITY = 16; // 元素数组 private Entry[] table; // 当前容量大小 private int size = 0; // 扩容的阀值 private int threshold; // Default to 0
2、ThreadLocalMap内部类-子类
-
static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }
3、ThreadLocalMap内部类-构造器
-
/** 初始化构造器:会初始化一个元素*/ ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { // 初始化表 table = new Entry[INITIAL_CAPACITY]; // 计算索引 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); // 生成Entry对象,并保存咋表的索引中 table[i] = new Entry(firstKey, firstValue); // 初始化元素后,默认size = 1 size = 1; // 设置下一次扩容的阔值 setThreshold(INITIAL_CAPACITY); } /** 初始化构造器:根据传入的ThreadLocalMap来初始化 */ private ThreadLocalMap(ThreadLocalMap parentMap){ // 根据TreadLocalMap 参数 初始化表 Entry[] parentTable = parentMap.table; // 获取参数表的大小 int len = parentTable.length; // 根据上面获取的大小初始化 setThreshold(len); table = new Entry[len]; // 循环获取元素 for (int j = 0; j < len; j++) { Entry e = parentTable[j]; if (e != null) { @SuppressWarnings("unchecked") ThreadLocal<Object> key = (ThreadLocal<Object>) e.get(); if (key != null) { Object value = key.childValue(e.value); Entry c = new Entry(key, value); int h = key.threadLocalHashCode & (len - 1); // 如果当前由元素,就循环到最后 while (table[h] != null) /* private static int nextIndex(int i, int len) { // 下一个就是索引 + 1 ,超出就索引为0 return ((i + 1 < len) ? i + 1 : 0); } */ // 次数是不会出现索引被占用,因为本身就是创建的一样大的空数组 h = nextIndex(h, len); // 此时table[h] 肯定是null,所以直接把c赋值 table[h] = c; size++; } } } }
4、ThreadLocalMap内部类-主要方法
环形索引函数
-
/** 获取当前索引下一个索引,处理了边界问题 */ private static int nextIndex(int i, int len) { return ((i + 1 < len) ? i + 1 : 0); } /** 获取当前索引上一个索引,处理了边界问题 */ private static int prevIndex(int i, int len) { return ((i - 1 >= 0) ? i - 1 : len - 1); }
getXXX函数
-
/** 根据传入的线程,获取对应的Entry() */ private Entry getEntry(ThreadLocal<?> key) { int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; if (e != null && e.get() == key) // 对应的entry存在且未失效且弱引用指向的ThreadLocal就是key,则命中返回 return e; else // 因为用的是线性探测,所有往后找还是有可能能够找到目标Entry值 return getEntryAfterMiss(key, i, e); } /** 调动getEntry未直接命中搞得时候调用此方法 */ private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { Entry[] tab = table; int len = tab.length; // 基于线性探测法不断向后探测直到遇到空Entry while (e != null) { ThreadLocal<?> k = e.get(); if (k == key) // 找到目标 return e; if (k == null) // 该entry对应的ThreadLocal已经被回收, // 调用expungeStaleEntry来清理无效的entry expungeStaleEntry(i); else // 继续找下一个索引 i = nextIndex(i, len); e = tab[i]; } return null; } /** * 这个函数是ThreadLocal的核心清理函数,它做的事情很简答: * 就是从staleSlot开始遍历,将无效(弱引用指向对象被回收)清理, * 即对应entry中的value置为null,将指向这个entry的table[i]置为null,直到扫到空Entry * 另外,在过程中还会对费控的entry作rehash * 可是说这个函数的作用就是从staleSlot开始清理连续段中的slot(断开强引用,rehash slot等) */ private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length; // 因为entry对应的 ThreadLocal 已被回收,value 设为null,显式断开强引用 // expunge entry at staleSlot tab[staleSlot].value = null; // 显式设置该entry 为 null,以便垃圾回收 tab[staleSlot] = null; size--; // Rehash until we encounter null Entry e; int i; for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); if (k == null) { // 清理对应ThreadLocal已被回收的entry e.value = null; tab[i] = null; size--; } else { // 对于还没有被回收的情况,需要做一次rehash // 如果对应的ThreadLocal 的ID 对len取模出来的索引 h 不为当前位置 i, // 则从h 向后线性探测到第一个空的slot,把当前的entry给挪过去。 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; } } } // 返回staleSlot之后第一个空的slot索引 return i; }
set、replaceStaleEntry、cleanSomeSlots函数
-
private void set(ThreadLocal<?> key, Object value) { // We don't use a fast path as with get() because it is at // least as common to use set() to create new entries as // it is to replace existing ones, in which case, a fast // path would fail more often than not. 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)]) { ThreadLocal<?> k = e.get(); if (k == key) { e.value = value; return; } if (k == null) { replaceStaleEntry(key, value, i); return; } } tab[i] = new Entry(key, value); int sz = ++size; if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } 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; }// We don't use a fast path as with get() because it is at // least as common to use set() to create new entries as // it is to replace existing ones, in which case, a fast // path would fail more often than not. 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)]) { ThreadLocal<?> k = e.get(); // 找到对应的entry if (k == key) { e.value = value; return; } // 替换失效的entry if (k == null) { replaceStaleEntry(key, value, i); return; } } tab[i] = new Entry(key, value); int sz = ++size; if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) { Entry[] tab = table; int len = tab.length; Entry e; // 向前扫描,找到最前的一个无效slot // Back up to check for prior stale entry in current run. // We clean out whole runs at a time to avoid continual // incremental rehashing due to garbage collector freeing // up refs in bunches (i.e., whenever the collector runs). int slotToExpunge = staleSlot; for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len)) if (e.get() == null) slotToExpunge = i; // 向后遍历table // Find either the key or trailing null slot of run, whichever // occurs first for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); // If we find key, then we need to swap it // with the stale entry to maintain hash table order. // The newly stale slot, or any other stale slot // encountered above it, can then be sent to expungeStaleEntry // to remove or rehash all of the other entries in run. // 找到了key,将其与无效的slot交换 if (k == key) { // 更新对应slot的value值 e.value = value; tab[i] = tab[staleSlot]; tab[staleSlot] = e; // Start expunge at preceding stale entry if it exists /* * 如果在整个扫描过程中(包含函数一开始向前扫描与 i 之前的向后扫描) * 找到了之前无效slot则以那个位置作为清理点 * 否则别以当前的i作为清理节点 */ if (slotToExpunge == staleSlot) slotToExpunge = i; // 从slotToExpunge 开始做一次联系段的清理,再做一次启发式清理 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } // If we didn't find stale entry on backward scan, the // first stale entry seen while scanning for key is the // first still present in the run. // 如果当前的slot 已失效,并且向前扫描过程中没有无效的slot, // 则更新slotToExpunge为当前变量 if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; } // If key not found, put new entry in stale slot // 如果key在table 中不存在,则在原地放一个即可 tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); // If there are any other stale entries in run, expunge them // 在探测过程中如果发现倔强的slot,则不做清理(联系段清理+启发式清理) if (slotToExpunge != staleSlot) cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); } /* 启发式地清理slot i 对饮gentry是非无效(指向的ThreadLocal没回收,或entry本身为空) n 是用于控制控制扫描次数的 正常情况下如果log n 次扫描没有发现无效的slot,函数就结束了 但是如果发现了无效的slot,将 n 置为table 的长度len,做一次连续段的清理了 再从下一个空的slot 开始继续扫描 这个函数有两处地方会都被调用,一处是插入的时候可能会被调用,另外一个是在替换无效slot的时候可能会被调用,区别是前者传入 的n为元素个数,厚泽为table的容量 */ private boolean cleanSomeSlots(int i, int n) { boolean removed = false; Entry[] tab = table; int len = tab.length; do { // i 在任何情况下自己都不会是一个无效的slot,所以从下一个开始判断 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; } /** */ private void rehash() { // 做一次全量清理 expungeStaleEntries(); // 因为做了一次清理,所以size很可能会变小。 // ThreadLocalMap这里的实现调低阔值来判断是否需要扩容 // threshold默认为len*2/3,所以这里的threshold - threshold / 4 相当于 len / 2 // Use lower threshold for doubling to avoid hysteresis 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); } } /** 扩容,因为需要保证table的容量len 为2的幂数,所以扩容既扩大2倍 */ 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 { // 线性探测来存放Entry int h = k.threadLocalHashCode & (newLen - 1); while (newTab[h] != null) h = nextIndex(h, newLen); newTab[h] = e; count++; } } } setThreshold(newLen); size = count; table = newTab; }
remove函数
-
// 删除map中的ThreadLocal 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; } } }
属性
/** 自身的hashCode值,用于-例:(threadLocalHashCode & (INITIAL_CAPACITY - 1) */
private final int threadLocalHashCode = nextHashCode();
/** 下一个要给出的hash值 */
private static AtomicInteger nextHashCode = new AtomicInteger();
/**
* 生成hash code 间隙的这个魔法值
* 可以让生成出来的值或ThreadLocal的Id较为均匀地分布在2的幂大小的数组中
*/
private static final int HASH_INCREMENT = 0x61c88647;
/** 返回下一个hash散列值 */
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
构造
public ThreadLocal() {}
主要方法
- 基本都是对ThreadLocalMap的操作
/** 为当前线程初始化副本变量值 */
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
return new SuppliedThreadLocal<>(supplier);
}
/** 获取当前线程的副本变量值 */
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
// 从ThreadLocalMap中获取K-V Entry节点
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
// 获取存储的value副本值,并且返回
T result = (T)e.value;
return result;
}
}
// ThreadLocal类返回的是null,其他子类实现的是对应的hashCode
// 如果找不到map,会初始化ThreadLocalMap,并把当前ThreadLocal和initialValue()副本值放入
return setInitialValue();
}
/** 保存当前线程的副本变量值 */
public void set(T value) {
Thread t = Thread.currentThread();
// 获取当前线程的map
ThreadLocalMap map = getMap(t);
if (map != null)
// 如果不为null。则修改当前线程的副本
map.set(this, value);
else
// 如果map为null 就会初始化ThreadLocalMap,并把当前ThreadLocal和副本value放入map
createMap(t, value);
}
/** 溢出当前线程的副本变量值 */
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
五、总结
ThreadLocal是一个本地线程副本变量工具类,主要用于将私有线程和该私有线程存放的副本对象做一个映射,各个线程之间的变量互不干扰,在高并发场景下,可实现无状态调用,特别适合于各个线程依赖不通的变量值完成操作场景