Java-多线程-ThreadLocal全解析
1 摘要
本文简单分析下ThreadLocal实现原理，再附上小例子。
2 ThreadLocal是什么
ThreadLocal提供线程级别的私有局部变量。这些变量和普通变量不同之处在于，通过get或set方法访问这类变量的每个线程都拥有一份独立初始化的变量副本。
ThreadLocal通常用private static修饰，可以将状态与该线程建立一对一的关系。
下面这个小例子，当第一次调用ThreadId.get()时会为每个线程生成一个全局唯一的、以1为步长自增的标识符，往后都会保持不变。
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadId {
// Atomic integer containing the next thread ID to be assigned
private static final AtomicInteger nextId = new AtomicInteger(0);
// Thread local variable containing each thread's ID
private static final ThreadLocal<Integer> threadId =
new ThreadLocal<Integer>() {
@Override protected Integer initialValue() {
return nextId.getAndIncrement();
}
};
// Returns the current thread's unique ID, assigning it if necessary
public static int get() {
return threadId.get();
}
}
在上面的例子中，只要线程存活且该ThreadLocal实例可访问，那么每个线程都会拥有一个隐式引用，指向自己拥有的ThreadLocal变量副本值。
- 下图上半部分展示两个线程共享一个普通静态变量的情况，下半部分展示ThreadLocal持有的变量情况：
3 原理
总的来说，其实就是多个线程共用一个某个类的静态ThreadLocal Instance，由线程级别的Map中的Entry的弱引用来指向这个共同的ThreadLocal Instance，而这个Entry的Value就是存的用户自定义的Value，所以可以达到线程独有一份的目的。关于Java内的各种引用可参考Java-内存模型-引用总结
ThreadLoca原理要点如下：
-
每个线程有自己的一个全局
ThreadLocalMap实例，ThreadLocalMap的key为ThreadLocal对象，value为用户自定义值。也就是说这个map可以放多个ThreadLocal对象。 -
但是一般来说，每次使用时，每个
ThreadLocal实例被多个线程共享而不是每个线程一个ThreadLocal实例。而且，我们应用的类对象里面有一个强引用指向ThreadLocal实例。比如以下代码，就是多个TestThread线程实例共享一个ThreadLocal Pet对象，但每个线程拥有一份独占的受ThreadLocal保护的Dog实例：
public class Demo2 { private static ThreadLocal<Dog> pet = new ThreadLocal<Dog>(){ @Override protected Dog initialValue() { return new Dog("tom", 1); } }; private static class TestThread implements Runnable{ @Override public void run() { // 获取由ThreadLocal保护的线程级别的初始值 Dog dog = pt.get(); // 改变该值 pt.set(new Dog("newName", 19)); // 从线程的ThreadLocalMap中清理该ThreadLocal对象 pt.remove(); } } -
ThreadLocalMap有一个
Entry数组，内嵌的Entry类其实是继承自WeakReference<ThreadLocal<?>>，即弱引用。这个弱引用指向该ThreadLocal实例（注意不是key去指向，因为这个Entry里根本就没有key这样一个对象）。 -
ThreadLocalMap的
Entry构造方法是Entry(ThreadLocal<?> k, Object v) { super(k); value = v; }。其中value是用户自定义的存储的值。
-
ThreadLocalMap的数据结构只有个Entry数组，而且放入元素发生Hash冲突时不是放入这个位置的链表而是调用
nextIndex方式继续查找适合的位置，在此过程中会调用一些方法清理失效（指Entry指向ThreadLocal实例的弱引用已经被GC清理）的Entry对，如果还是空间不够就扩容。
注意：网上很多文章说ThreadLocal原理是有个Map以每个Thread实例为key，这是绝对错误的。
还有人说Entry的key有一个弱引用指向ThreadLocal实例，也是错误的，因为Entry对象本身就是一个指向ThreadLocal实例的弱引用，存放在ThreadLocalMap的Entry数组内。
3.1 ThreadLocal的属性
3.1.1 HashCode
private final int threadLocalHashCode = nextHashCode();
// 两个连续的hashcode差值
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
private static AtomicInteger nextHashCode = new AtomicInteger();
ThreadLocalMap类型的Thread.threadLocals和inheritableThreadLocals依赖于附属于每个线程的线性探测哈希映射。
ThreadLocal对象充当key，通过threadLocalHashCode搜索。 这是一个自定义哈希代码（仅在ThreadLocalMaps中有用），它消除了在相同线程使用连续构造的ThreadLocals的常见情况下的冲突，同时在不太常见的情况下保持良好行为。
3.1.2 HASH_INCREMENT = 0x61c88647
关于HASH_INCREMENT = 0x61c88647 这个魔数，网上查了一些资料，大致原因是因为此数为黄金分割，可以让数组内的hash分布更均匀。更多内容可以参考：What is the meaning of 0x61C88647 constant in ThreadLocal.java
3.2 ThreadLocal构造方法
public ThreadLocal() {}
这里什么都没做。
3.3 成员方法
3.3.1 ThreadLocal.initialValue
protected T initialValue() {
return null;
}
这个方法会在第一次使用get方法时调用setInitialValue时执行，除非在此之前已经调用了set方法。
一般来说该方法只会被调用一次，但如果使用remove清空随后又调用get方法时，又会再次调用initialValue。
可以看到该方法默认返回的初值为null，如果我们想自定义一个初值，一般就是用匿名内部类的方式重写该方法实现自定义初值，比如以下代码定义了返回一个new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")的DateFormat类型的初值的ThreadLocal：
ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>() {
@Override
protected DateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
} };
3.3.2 ThreadLocal.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;
}
}
return setInitialValue();
}
get方法很重要，他被用来获取当前thread私有的threadlocal保护的变量副本。
如果还没有当前线程的ThreadLocalMap或者该map中不存在以该ThreadLocal对象为key的Entry，那此时该线程的ThreadLocal保护的变量副本肯定不存在，则此时首先将其初始化为调用initialValue方法的返回值。
ThreadLocal.setInitialValue方法如下：
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
可以看到他会先调用initialValue方法去拿到初始值，然后获取当前线程的ThreadLocalMap。如果map不存在就以当前thread和value创建ThreadLocalMap；如果已经存在就以当前ThreadLocal实例为key，value为值放入该ThreadLocalMap。
ThreadLocal.getMap方法如下：
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
注意，这里的t就是当前线程对象，t.threadLocals在Thread类里的声明如下：
ThreadLocal.ThreadLocalMap threadLocals = null;
可以看到，threadLocals其实就是每个线程对象独有的一个ThreadLocalMap类型的实例对象。具体可参考后文ThreadLocalMap
3.3.3 ThreadLocal.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);
}
该方法用来设置ThreadLocal保护的值，跟前面提到的setInitialValue方法差不多，只不过这里指定了放入ThreadLocalMap的自定义value。
3.3.4 ThreadLocal.remove
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
该方法用于获取当前线程的ThreadLocalMap，然后从其中移除当前ThreadLocal实例为key的Entry。
3.4 内部类-SuppliedThreadLocal
static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
private final Supplier<? extends T> supplier;
SuppliedThreadLocal(Supplier<? extends T> supplier) {
this.supplier = Objects.requireNonNull(supplier);
}
@Override
protected T initialValue() {
return supplier.get();
}
}
这个类的主要作用是配合withInitial设定初始值，其实就是利用Supplier的lambda表达式写法。示例如下：
private static ThreadLocal<Dog> pt = ThreadLocal.withInitial(() -> new Dog("tom", 1));
3.5 ThreadLocalMap
3.5.1 简述
ThreadLocalMap是一个自定义的类HashMap，他只适合维护threadlocal values，没有向外暴露任何方法。
为了应对长期和高负荷的使用，所以采用了WeakReference来修饰该map的key。也就是说当这些key无其他强引用时，GC会将他们回收。但需要注意的是，因为创建弱引用key的时候没有采用RefereceQueue，所以只能保证那些已经没用的的Entry会在entry table超出大小限制时被移除。
3.5.2 ThreadLocalMap类声明
static class ThreadLocalMap
可以看到，ThreadLocalMap是ThreadLocal里的一个静态内部类，而且限制使用域是本类、和同包(java.lang，包括Thread类)。
3.5.3 成员变量
以下是ThreadLocalMap的一些成员标量，和HashMap类似：
// Entry Table初始容量
private static final int INITIAL_CAPACITY = 16;
// Entry数组，按需库容，且长度必须是2的n次方
private Entry[] table;
// Entry数组元素个数
private int size = 0;
// Entry数组扩容时的阈值，默认为0
private int threshold;
3.5.4 内部类Entry
static class Entry extends WeakReference<ThreadLocal<?>> {
// 存放指定的value
Object value;
Entry(ThreadLocal<?> k, Object v) {
// 调用父类WeakReference构造方法，构建一个指向ThreadLocal实例的弱引用
super(k);
// 保存指定的value值
value = v;
}
}
Entry是ThreadLocalMap的静态内部类，他继承自WeakReference，也就是说Entry本身是个指向ThreadLocal对象的弱引用，记住这一点十分重要。
可以看到Entry内部只显示存放了指定的value对象，而构造方法Entry(ThreadLocal<?> k, Object v)里构建了一个到ThreadLocal实例的弱引用。
调用Entry.get方法其实就是调用其祖先类Reference.get方法，获取到的referent值为null时，说明已经该弱引用已经不存在了，代表此时该Entry可以被Entry数组剔除，这种无效的Entry被称为stale entry即过期的Entry。
3.5.5 ThreadLocalMap构造方法
有两个：一个是public一个是private。
- pubic
这个方法就是传入第一个ThreadLocal对象作为key，value作为值，构建一个ThreadLocalMap。需要注意的是，ThreadLocalMap是懒创建的，也就是说直到有Entry需要加入才会调用此方法。可以参考之前ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { // 初始长度为16的Entry数组 table = new Entry[INITIAL_CAPACITY]; // 用每个key的threadLocalHashCode和(1111)按位做与操作得到Entry应该放的下标 // 这样做的好处就是不管你threadLocalHashCode再大，计算结果也不会超过15 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); // 初始化Entry，并放入数组对应位置 table[i] = new Entry(firstKey, firstValue); // Entry数组大小更改为1 size = 1; // 根据容量重设扩容阈值 setThreshold(INITIAL_CAPACITY); }ThreadLocal.setInitialValue和ThreadLocal.set方法，里面有调用ThreadLocal.createMap方法：void createMap(Thread t, T firstValue) { // 这里就以本ThreadLocal对象为key，首个自定义值为value来构造ThreadLocalMap t.threadLocals = new ThreadLocalMap(this, firstValue); } - private
这个构造方法由private ThreadLocalMap(ThreadLocalMap parentMap) { 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) h = nextIndex(h, len); table[h] = c; size++; } } } }createInheritedMap方法调用，传入的参数是父线程的ThreadLocalMap。将会创建一个ThreadLocalMap包括所有父map内的ThreadLocal。
3.5.6 扩容相关方法
// 设置扩容阈值为容量的三分之二
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
// 下标i+1的方式从小往大的下标方向递推
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
// 下标i-1的方式从大往小的下标方向递推
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
3.5.7 扩容方法resize
将Entry数组扩容为以前大小的两倍，顺便清理发生hash碰撞时key已为null的entry，具体步骤如下：
- 创建新的Entry[]
- 然后循环遍历老的Entry[]
- 如果Entry元素存在就去获取弱引用的ThreadLocal实例，
- 通过Reference.get方法判断ThreadLocal引用是否为空
- 此时如果ThreadLocal引用为空，代表由于Entry为弱引用导致该引用已经被GC回收，那么直接把当前Entry置为null做清理;
- ThreadLocal引用不为空情况的处理：
- 否则通过threadLocalHashCode和 (新的数组长度-1) 按位与的方式得到新的数组下标
- 接着判断该下标位置是否已存在元素，若存在就反复调用nextIndex方法从小往大的下标方向递推求新的下标
- 找到合适位置后，将元素entry放入新的数组中的下标位置，并将临时元素计数器加一
- 更新扩容阈值，并将临时变量赋值给对应的entry table实例变量。扩容完成。
代码如下：
private void resize() {
// 1.创建新的Entry[]，长度为旧数组两倍
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
int count = 0;
// 2.然后循环遍历老的Entry[]
for (int j = 0; j < oldLen; ++j) {
Entry e = oldTab[j];
if (e != null) {
// 3.如果Entry元素存在就去获取弱引用的ThreadLocal
ThreadLocal<?> k = e.get();
if (k == null) {
// 4.1此时如果ThreadLocal引用已经为空，代表已经被GC回收，那么直接把当前Entry置为null;
e.value = null; // Help the GC
} else {
// 4.2.1否则通过threadLocalHashCode和(新的数组长度-1)按位与的方式得到新的数组下标
int h = k.threadLocalHashCode & (newLen - 1);
// 4.2.2接着判断该下标位置是否已存在元素，若存在就反复调用nextIndex方法求新的下标
while (newTab[h] != null)
h = nextIndex(h, newLen);
// 4.2.3将元素entry放入新的数组中的下标位置，并将临时元素计数器加一
newTab[h] = e;
count++;
}
}
}
// 5.更新扩容阈值，并将临时变量赋值给对应的entry table实例变量。扩容完成。
setThreshold(newLen);
size = count;
table = newTab;
}
3.5.8 放入元素set
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);
// 寻找新entry放入的适合位置。
// hash冲突时再hash方式为nextIndex从下标小的方式往大的方向递推
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 如果计算出的下标位置存在entry
// 且该ThreadLocal实例key和参数ThreadLocal对象相同，那就更新value。set结束
if (k == key) {
e.value = value;
return;
}
// 如果计算出的下标位置存在entry且该ThreadLocal实例key为null
// 此时说明该entry的弱引用已经失效，就用生成新的entry替换。set结束
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
// 如果计算出的下标位置存在entry且该ThreadLocal实例key和参数ThreadLocal不同，就进入下一次循环
// 否则说明该位置e = null ，跳出循环
}
// 此时e = null，也就是说该数组位置不存在entry
// 用参数生成一个新的entry，放入此位置即可
tab[i] = new Entry(key, value);
// 大小加一
int sz = ++size;
// 如果没有发生清理行为且 当前数组元素个数达到扩容阈值，就需要rehash
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
ThreadLocalMap put元素遇到有效Entry对，发生hash冲突时，不同于hashMap是放入该位置的链表，而是通过nextIndex方法从下标小的往大的方向递推继续找合适位置。
3.5.8 获取元素
// 获取ThreadLocal实例对应的Entry
// 如果没能匹配到就调用getEntryAfterMiss
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
// 当没有找到ThreadLocal实例对应的Entry时，只能调用该方法来查找
// 这个方法也会在查找过程中顺便清理无效的弱引用Entry
// i为数组下标，e为当前下标对应的Entry
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
// 找到该entry就返回
return e;
if (k == null)
// 该位置ThreadLocal引用为空，清理该etnry
expungeStaleEntry(i);
else
// 否则继续递推查找
i = nextIndex(i, len);
e = tab[i];
}
// 到这里，说明没有找到
return null;
}
可以看到在没有一次性找到对应位置的元素的时候调用了getEntryAfterMiss方法，会在查找过程中不断清理无效的弱引用Entry。
3.5.9 移除元素
// 将传入的参数ThreadLocal实例对应的Entry弱引用去掉，并把Entry从map中移除
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;
}
}
}
3.5.10 替换失效Entry
// 替换失效的数组位置上的Entry，在此过程中将遇到的失效弱引用Entry移除
// key和value为新的值，staleSlot为匹配到的第一个失效Entry下标
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// 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).
// 倒推以检查当前运行中的已失效Entry。
// 我们一次清理整个运行，以避免由于垃圾收集器释放串联的refs（即，每当收集器运行时）不断的增量重复。
int slotToExpunge = staleSlot;
// 这里得到的slotToExpunge是从后往前推的最后一个e!=null但是e.get()==null的下标
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
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();
// 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.
// 如果匹配到键，那么我们需要将它与失效Entry交换以维护哈希表顺序。
// 然后可以将新陈旧的插槽或其上方遇到的任何其他陈旧插槽发送到expungeStaleEntry以删除或重新运行运行中的所有其他条目。
if (k == key) {
// 如果存在该ThreadLocal实例的Entry，就覆盖该value
e.value = value;
// 这里staleSlot为匹配到的第一个失效Entry下标
// 赋值后tab[i]!=null但是tab[i].get()==null
tab[i] = tab[staleSlot];
// 原staleSlot Entry替换为value更新后的e
tab[staleSlot] = e;
// Start expunge at preceding stale entry if it exists
// slotToExpunge == staleSlot的情况是在前面倒推运算中没有找到失效的Entry
if (slotToExpunge == staleSlot)
// 注意这里i下标对应的元素是tab[staleSlot]
slotToExpunge = i;
// 移除slotToExpunge位置的Entry顺便移除一些失效Entry
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.
// 该Entry弱引用失效，且在前面倒推查找中没有匹配到失效的Entry
if (k == null && slotToExpunge == staleSlot)
// 那就把当前这个对应失效弱引用的i给slotToExpunge，然后继续循环
slotToExpunge = i;
}
// If key not found, put new entry in stale slot
// 走到这里说明没有匹配到ThreadLocal key
// 把staleSlot处的value设为空(help gc)
tab[staleSlot].value = null;
// 该位置设为由新的ThreadLocal实例为key，新value的Entry
tab[staleSlot] = new Entry(key, value);
// 不相等说明找到了另外的失效的Entry位置，干掉他们并顺便清理出一点空间
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
3.5.11 自动过期
// 清理一些Entry
// 清理次数由当前数组大小是2的多少倍决定
// 所以叫cleanSomeSlots - -|
// 当发生了清理就返回true，否则返回false
private boolean cleanSomeSlots(int i, int n) {
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
// 找到下一个下标位置，如果失效entry就干掉
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;
}
// 先清理所有失效的Entry
// 如果 此时size还是大于之前的四分之三，就扩容
private void rehash() {
expungeStaleEntries();
// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4)
resize();
}
// 遍历数组，移除失去弱引用的旧Entry
private void expungeStaleEntries() {
Entry[] tab = table;
int len = tab.length;
for (int j = 0; j < len; j++) {
Entry e = tab[j];
// 找到失去弱引用的Entry，将该Entry所在下标传入expungeStaleEntry将其干掉
if (e != null && e.get() == null)
expungeStaleEntry(j);
}
}
// 此方法是真正移除失去弱引用的Entry的方法，顺便移除遇到的碰撞位置的失效Entry
// 参数staleSlot 是该Entry所在下标
// 返回下标i，此时tab[i]为null
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
// 数组原始长度
int len = tab.length;
// 移除Entry的value和本身的引用
tab[staleSlot].value = null;
tab[staleSlot] = null;
// 数组大小减一
size--;
// Rehash until we encounter null
Entry e;
int i;
// 循环的方式去掉弱引用失效的entry
// 循环开始条件是让该下标对原始数组长度求模
// 循环结束条件是Entry为null
// 每次循环完又再次nextIndex计算新下标
// 循环过程中还会把清理了entry位置的按nextIndex的往后查找
// 将找到的弱引用为null的清理，
// 非null且为递推移动放入的元素按规则放入新位置
// 这样可以避免清理元素后无法递推查找其他元素
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {
// 找到弱引用失效的entry，干掉
e.value = null;
tab[i] = null;
size--;
} else {
// 此时表示e的弱引用存在
// 我们已经熟悉了这种获取下标方式
int h = k.threadLocalHashCode & (len - 1);
// 不相等表示存在hash冲突，放入的位置是用N次nextIndex计算后的新位置
// 现在由于递推之前的位置发生了清理，所以会导致递推查找失败
// 现在必须把该位置的entry放到新的null位置
if (h != i) {
// 将递推i位置的Entry置空
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
// 找到一个新的无entry的数组下标
while (tab[h] != null)
h = nextIndex(h, len);
// 将e移动到新的数组下标位置
tab[h] = e;
}
}
}
// 此时tab[i]为空
return i;
}
4 坑
4.1 内存泄露
因为代码中一般长期存在指向ThreadLocal对象的强引用，那么，使用了该ThreadLocal的线程的ThreadLocalMap里的Entry之key，虽是指向该ThreadLocal对象的弱引用，但是因为代码对ThreadLocal强引用（就是声明如private static ThreadLocal<Dog> pt = new ThreadLocal<Dog>()的强引用）持续存在，导致这类弱引用Entry无法被及时回收。
也就是说，这类弱引用Entry会随着线程持续存在而存在，造成内存泄露。所以我们应该在每个线程使用完ThreadLocal对象后，调用remove方法，手动移除该Entry。
4.2 线程池
线程池中的Thread对象就那么几个，都是复用的。也就是说，他们的ThreadLocalMap对象是不会变的，会导致Runnable运行时的ThreadLocal值交叉混用，出现问题。那么就需要在每个Runnable的run方法执行完后执行threadLocal.remove()，示例如下：
ExecutorService executorService = new ThreadPoolExecutor(5,5,1, TimeUnit.MINUTES,workQueue,new ThreadPoolExecutor.DiscardPolicy()){
@Override
protected void afterExecute(Runnable r, Throwable t)
{
threadLocalName.remove();
super.afterExecute(r, t);
}
};
5 例子
5.1 DateFormat
SimpleDateFormat并不是线程安全的，所以在阿里的Java开发规范里推荐了用ThreadLocal保证线程安全的做法：
private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>() {
@Override
protected DateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
} };
String startTimeStr = "2018-01-11 02:17:02.806";
try {
Date startTime = df.get().parse(startTimeStr);
System.out.println("startTime=" + startTime);
String dfStr = df.get().format(new Date());
System.out.println("dfStr=" + dfStr);
}catch (ParseException e) {
e.printStackTrace();
}
参考文档
JavaDoc-java.lang.ThreadLocal
1543
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
