一 前言
在多线程并发的学习中，我们总会接触到一个类，即是ThreadLocal。这个类的作用是提供线程内的局部变量，换句话来说，就是提供一个能与当前线程绑定的局部变量。这个变量能够在多线程并发的环境下保证每个线程中变量的独立性。
只要线程处于活动状态并且Threadocal实例可以访问，每个线程就拥有对其线程局部变量副本的隐式引用；在一个线程消失之后，线程本地实例的所有副本都会被垃圾收集（除非存在对这些副本的其他引用）
我们可以看下该类的操作：
public class ThreadLocalTest {
private static ThreadLocal<Integer> integerThreadLocal = new ThreadLocal<>();
public static void main(String[] args) {
integerThreadLocal.set(3);
System.out.println(integerThreadLocal.get());
integerThreadLocal.remove();
System.out.println(integerThreadLocal.get());
}
}
输出为：
3
null
那么效果如何呢，看下面这个例子：
public class ThreadLocalTest {
private static ThreadLocal<Integer> integerThreadLocal = new ThreadLocal<>();
public static void main(String[] args) {
LocalThread thread1 = new LocalThread();
thread1.setValue(3);
thread1.start();
LocalThread thread2 = new LocalThread();
thread2.setValue(4);
thread2.start();
}
public static class LocalThread extends Thread {
int value;
public void setValue(int value) {
this.value = value;
}
@Override
public void run() {
integerThreadLocal.set(value);
for (int i = 0; i < 2; i++) {
System.out.println(integerThreadLocal.get());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
输出结果为：
4
3
3
4
从中我们可以看出两个线程中对于ThreadLocal类中的变量是不一样的。
下面让我们从源码的角度来看一下这个类
二 源码解析
2.1 基础字段
先从基础部分看起：
// hash code
private final int threadLocalHashCode = nextHashCode();
// 原子性操作类型
private static AtomicInteger nextHashCode =
new AtomicInteger();
// 每次增加的hash code
private static final int HASH_INCREMENT = 0x61c88647;
// 下一个hash值
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
从上面的定义可以知道，ThreadLocal的threadLocalHashCode是从0开始，每新建一个ThreadLocal，对应的hashcode就加0x61c88647。值得注意的是控制hashcode增加的三个方法或字段为类方法或类字段，而代表当前实例对象hashcode的字段则是threadLocalHashCode。
生成hash code间隙为0x61c88647这个魔数，可以让生成出来的值较为均匀地分布在2的幂大小的数组中。对应的十进制为1640531527。均匀分布的好处在于很快就能探测到下一个临近的可用slot，从而保证效率。
2.2 默认值
ThreadLocal类中也提供了默认值的设置，如下：
// 为ThreadLocal设置默认的get初始值，需要重写
protected T initialValue() {
return null;
}
// 创建一个线程局部变量。通过在Supplier上调用get方法确定变量的初始值
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
return new SuppliedThreadLocal<>(supplier);
}
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();
}
}
Supplier类是一个只有get()方法的消费式函数式接口，通过SuppliedThreadLocal继承了ThreadLocal类，从而实现了对于initialValue()方法的覆盖。
具体的使用方法如下：
// 此处输出为3而不是null
public static void main(String[] args) {
Supplier supplier = () -> 3;
System.out.println(ThreadLocal.withInitial(supplier).get());
}
2.3 ThreadLocalMap的定义
ThreadLocal类的内部维护了一个静态内部类：
static class ThreadLocalMap {
}
ThreadLocalMap是一个自定义哈希映射，仅用于维护线程本地变量值。每个线程都有一个ThreadLocalMap类型的threadLocals变量。
此处为Thread类中的字段：
ThreadLocal.ThreadLocalMap threadLocals = null;
在创建与ThreadLocal关联的Map时，便会将当前线程与对应的Map关联起来：
// 创建与ThreadLocal关联的Map。在InheritableThreadLocal中重写。
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
在其内部中最核心的实现应该是Entry静态类：
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
// 将ThreadLocal注册成为弱引用，避免将ThreadLocal置为null时，因为其仍保持与Entry的关联而导致ThreadLocal不能被垃圾收集器回收
super(k);
value = v;
}
}
Entry的key为ThreadLocal，value为ThreadLocal对应的值。
关于弱引用的资料可以查看：https://www.cnblogs.com/absfree/p/5555687.html
其基础字段为：
// 初始化容量，必须为2的幂
private static final int INITIAL_CAPACITY = 16;
// 可增长的缓存数组
private Entry[] table;
// table中entries的数量
private int size = 0;
// 下次扩容的阈值
private int threshold; // Default to 0
// 设置调整大小阈值以保持最差的2/3负载系数。
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
// 增加i并取余len
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
// 减少i并取余len
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
其构造函数也可以先看下：
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
// 取hash code
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 利用firstKey与firstValue构建一个新的Entry
table[i] = new Entry(firstKey, firstValue);
size = 1;
// 设置扩容阀值，取传入值得2/3
setThreshold(INITIAL_CAPACITY);
}
// 构造一个新映射，包括给定父映射中的所有可继承ThreadLocals。仅由createInheritedMap调用。
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) {
// 取出哈希槽中当前Entry的key
// 此处的e.get()方法是Reference类中的方法,返回此引用对象的引用对象
@SuppressWarnings("unchecked")
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
// key不为空即代表对应线程的ThreadLocal未被清除
if (key != null) {
// 此处的childValue(e.vale)方法为InheritableThreadLocal覆盖实现
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
// 取hash code
int h = key.threadLocalHashCode & (len - 1);
// 线性探查法解决冲突
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
其他部分则留到后面讲解
值得注意到的是，此处第二个构造函数的访问限定符为private，那么在ThreadLocal里面是由哪个类来调用他的呢：
// 工厂方法创建继承本地线程的映射。旨在仅从Thread构造函数调用。
static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
return new ThreadLocalMap(parentMap);
}
大家可能会问，一个Thread类拥有一个threadLocals来存放ThreadLocalMap，那这个构建的类是来干嘛的， 那让我们看看到底是哪里会调用这个方法：
答案是在Thread类中的init()方法中会调用该方法，并将该方法的返回值放置到以下字段：
// 与此线程相关的InheritableThreadLocal值。此映射由InheritableThreadLocal类维护。
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
通过这个可以满足开发者子线程获得父线程ThreadLocal的需求
2.4 get()方法
// 返回当前线程副本的值，如果没有存在则使用initialValue设置默认值并返回
public T get() {
Thread t = Thread.currentThread();
// 通过当前线程得到对应的map
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;
}
}
// 返回默认值，无则为null
return setInitialValue();
}
此处就是之前说过的与Thread类关联起来的字段，在LocalThread的每个实例中都可以根据这个当前线程得到相应的map：
// 获取与ThreadLocal关联的Map。
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
并且该ThreadLocalMap类是一个静态类，说明任何实例化ThreadLocal或其子类的对象，他们所存放的map都是同一个。
private Entry getEntry(ThreadLocal<?> key) {
// hash取址
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
// 使用线性探查法解决hash冲突
return getEntryAfterMiss(key, i, e);
}
此处的获取get()调用了Reference类里面的方法：
// 返回该引用对象的引用
public T get() {
return this.referent;
}
首先根据key的hash code找到在table中对应的Entry，若找到则返回e，若没有找到则可能是因为发生冲突而导致与当前线程关联的entry存放在了后面，此时调用getEntryAfterMiss(key, i, e);方法继续寻找。此处使用了Hash表中的线性探查法。
// 在直接散列槽（direct hash slot）中找不到密钥时使用的getEntry方法的版本。
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal<?> k = e.get();
// 此时相当于找到当前线程对于的entry
if (k == key)
return e;
// 此处说明map的key已被置为null，但value还在，此时需要解决清除掉已经失效的条目
if (k == null)
// 若执行该方法后，tab[i]不为null,即是说明在i后面的数据被移动到i处，此时可以继续寻找，否则停止寻找
expungeStaleEntry(i);
else
// 增加i并对len取余，继续寻找
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
从指定的位置开始不断向下查找，如果此时找到了当前线程对应的entry则直接返回。若查找到null，在entry存在的情况下key为null说明该数据是一个脏数据，需要清除掉已经失效的条目。若处理后该处仍为null，则说明后续已无元素，此时便可以结束循环返回null。若处理后该处不为null，则说明在i后面的数据被移动到i处，此时可以继续寻找。
这里可以清楚地了解到expungeStaleEntry(i)方法是怎样清除掉已经失效的条目：
// 通过重新处理staleSlot和下一个空槽之间的任何可能发生冲突的条目来清除陈旧条目。这也会消除在尾随空值之前遇到的任何其他陈旧条目。
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 除当前脏entry
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry e;
int i;
// 持续往后查找entry[]，直到遇到table[i]==null时结束,并且返回此时的i
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// 如果在向后搜索过程中再次遇到脏entry，同样将其清理掉
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
// 处理rehash的情况，相当于将Entry e重新放置到离h最近的位置，也可以说是i之前。
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
// 与Knuth 6.4算法R不同，我们必须扫描到null，因为可能有多个条目已过时。
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
该方法主要做了这么几件事情：
- 清理当前脏entry，即将其value引用置为null，并且将table[staleSlot]也置为null。
- 从当前staleSlot位置向后（nextIndex）继续搜索，直到遇到哈希桶（tab[i]）为null的时候退出；
- 若在搜索过程再次遇到脏entry，继续将其清除。
此处是只针对一段哈希桶（tab[i]）不为null的片段进行操作，并没有涉及到所有哈希槽。
若在map中没有发现以当前线程为key的map，则调用setInitialValue()方法来设置初始化值：
// 用于建立initialValue，返回initialValue的值
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;
}
根据方法名理解起来都不困难，无非是存在map则设置为为默认值，否则创造map
map的set方法在下面set()方法的部分再进行讲解，此时我们先来看下createMap(t, value);：
// 创建与ThreadLocal关联的Map。在InheritableThreadLocal中重写。
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
使用了ThreadLocalMap的构造函数。
2.5 set()方法
// 设置当前线程对应的value
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
里面的调用方法在方法处都讲过一遍了，此处简单地过一下在get()方法中出现过的方法调用：
getMap(t)：拿取了当前线程的threadLocal变量。
createMap(t, value)：调用了ThreadLocalMap的构造函数。
此处的set(ThreadLocal<?> key, Object value)方法是在ThreadLocalMap中实现的private方法：
// 设置与key关联的值
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
// 缓存数组长度
int len = tab.length;
// hash code
int i = key.threadLocalHashCode & (len-1);
// 从i处开始线性探查相应的key
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 找到了则使新值替换旧值
if (k == key) {
e.value = value;
return;
}
// 遇到脏entry,此时通过replaceStaleEntry进行处理
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 插入新的entry
tab[i] = new Entry(key, value);
int sz = ++size;
// 若此时没有移除任何一个脏数据且当前entry存放数量到达阀值则rehash
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
此处我们能够看到插入新的entry后是会对map进行扩容的，即不存在map内部全为非null的情况，因此环形查找一定会在某一个点终止循环。
在该方法中针对脏entry做了这样的处理：
- 如果当前table[i]！=null的话说明hash冲突就需要向后环形查找，若在查找过程中遇到脏entry就通过replaceStaleEntry进行处理；
- 如果当前table[i]==null的话说明新的entry可以直接插入，但是插入后会调用cleanSomeSlots方法检测并清除脏entry
当遇到脏数据的时候使用replaceStaleEntry(key, value, i)方法清除脏数据，并且将指定值插入到指定键的位置：
// 将设置操作期间遇到的脏entry替换为指定键的entry。无论是否已存在指定键的entry,传入value参数的值将被存储在entry中。
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// 向前找到第一个脏entry
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
// 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();
// 如果在向后环形查找过程中发现key相同的entry就覆盖并且和脏entry进行交换
if (k == key) {
// 修改值
e.value = value;
// 将该entry与前方置空的hash Slot互换
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// 如果向前未搜索到脏entry，并且在查找过程中还未发现脏entry，那么就以当前位置作为cleanSomeSlots的起点
if (slotToExpunge == staleSlot)
slotToExpunge = i;
// 搜索脏entry并进行清理
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
//如果向前未搜索到脏entry，则在查找过程遇到脏entry的话，后面就以此时这个位置作为起点执行cleanSomeSlots
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// 如果在查找过程中没有找到可以覆盖的entry，则将新的entry插入在脏entry
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// If there are any other stale entries in run, expunge them
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
由于该方法中存在向前环形查找脏entry与向后查找可替换entry，因此可以分为四种情况来进行讲解：
-
向前查找到了脏entry
-
向后查找到了可覆盖的entry
一开始slotToExpunge初始状态与staleSlot，当向前环形查找到了脏entry时，则将slotToExpunge更新为当前脏数据的索引，直到遇到
table[i] == null时前向搜索结束。接下来的for循环中进行了后向环形查找，如果找到了可覆盖的entry，则先覆盖当前位置i中的entry，然后再与staleSlot位置上的脏entry进行交换。e.value = value; // 将该entry与前方置空的hash Slot互换 tab[i] = tab[staleSlot]; tab[staleSlot] = e;交换后
i处的位置就是脏数据了。最后使用cleanSomeSlots方法以slotToExpunge为起点开始清理脏entry。此处之所有不用
slotToExpunge与可覆盖entry进行交换的原因是：该map中的键值对是进行环形查找的，因此slotToExpunge不一定会在指定key的hash的后面，而staleSlot因为一开始就是因为插入时候才被发现是脏数据，因此直接与其交换是没有问题的。 -
向后没有查找到可覆盖的entry
一开始slotToExpunge初始状态与staleSlot，当向前环形查找到了脏entry时，则将slotToExpunge更新为当前脏数据的索引，直到遇到
table[i] == null时前向搜索结束。接下来的for循环中进行了后向环形查找，如果没有找到可覆盖的entry并且后向环形查找过程结束。则将新插入的entry直接放在staleSlot处。tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value);最后使用
cleanSomeSlots方法以slotToExpunge为起点开始清理脏entry。
-
-
向前环形查找没有查找到脏entry
-
向后查找到了可覆盖的entry
若在前向环形查找的整个过程中都没有遇到脏entry，则slotToExpunge的初始状态依旧与staleSlot相同。接下来的for循环进行环形查找，若此时遇到了脏entry，则更新slotToExpunge的位置为当前位置i。
if (k == null && slotToExpunge == staleSlot) slotToExpunge = i;若查找到了可覆盖的entry，则先覆盖当前位置的entry，然后再与staleSlot位置上的脏entry进行交换。
e.value = value; tab[i] = tab[staleSlot]; tab[staleSlot] = e;最后使用
cleanSomeSlots方法以slotToExpunge为起点开始清理脏entry。 -
向后环形查找没有可覆盖的entry
若在前向环形查找的整个过程中都没有遇到脏entry，则slotToExpunge的初始状态依旧与staleSlot相同。接下来的for循环进行环形查找，若此时遇到了脏entry，则更新slotToExpunge的位置为当前位置i。 并且将slotToExpunge更新到当前位置。
if (slotToExpunge == staleSlot) slotToExpunge = i;最后使用
cleanSomeSlots方法以slotToExpunge为起点开始清理脏entry。
-
以上便是replaceStaleEntry方法中的所有情况。下面我们再看一下是怎样使用cleanSomeSlots方法来清理脏entry的：
首先是一开始调用的expungeStaleEntry(slotToExpunge)方法，会清除指定staleSlot后面table[i]不为null范围内的一系列脏entry。最后返回的是清除脏entry后遇到的第一个entry为null的索引，具体可以看上文对其的分析。
// 尝试扫描并处理一些脏entry。当添加新元素或另一个脏entry被清除时，将调用此方法。
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];
// 清除脏entry
if (e != null && e.get() == null) {
n = len;
removed = true;
i = expungeStaleEntry(i);
}
} while ( (n >>>= 1) != 0);
return removed;
}
在调用该方法的情况中，索引i所指向的entry可能是一个空entry或者刚刚放入一个新entry，反正肯定不是一个脏entry。
参数n的用处主要用于扫描控制（scan control），从while中是通过n来进行条件判断的说明n就是用来控制扫描趟数（循环次数）的。在扫描过程中，如果没有遇到脏entry就整个扫描过程持续log2(n)次，log2(n)的得来是因为n >>>= 1，每次n右移一位相当于n除以2。如果在扫描过程中遇到脏entry的话就会令n为当前hash表的长度（n=len），再扫描log2(n)趟，注意此时n增加无非就是多增加了循环次数从而通过nextIndex往后搜索的范围扩大。
不是很清楚为什么使用n >>>= 1来判断扫描趟数，如果有懂的大神欢迎留言。。
如果是在set方法插入新的entry后调用，n位当前已经插入的entry个数size；如果是在replaceSateleEntry方法中调用,n为哈希表的长度len。
如果有清理过脏entry则返回true，否则返回false。
最后的最后，如果将创建了一个新的entry并且此时不存在脏数据，且map中存储的entry数量已经达到阀值时，便需要rehash了。
private void rehash() {
expungeStaleEntries();
// 使用较低的阈值加倍以避免滞后
if (size >= threshold - threshold / 4)
resize();
}
首先是清除脏entry：
// 清除缓存数组中的所有脏entry
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);
}
}
前面是判断size >= 2 * threshold / 3,此处则判断了size >= 3 * threshold / 4 。符合条件则调用resize():
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
// 扩容为两倍
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
int count = 0;
// 将旧map中的entry迁移到新entry上
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 {
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
setThreshold(newLen);
size = count;
table = newTab;
}
2.6 remove()方法
在上述的方法中，我们经常能够看到在索引位置i中，Entry e = table[i]，e != null && e.get() == null的情况发生，我们管这类数据为脏数据，那他是怎样出现的呢，让我们继续看下一个方法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)]) {
// 找到包含指定key的entry
if (e.get() == key) {
// 清除，即将key置为null，此时该entry变成了脏数据
e.clear();
// 清除脏数据
expungeStaleEntry(i);
return;
}
}
}
public void clear() {
this.referent = null;
}
this.referent = null;是由于Entry继承了WeakPerference，使用了referent来存储key，将其置为null便等同于将key置为null。
三 结论
与我们常用的Map不同，java里大部分Map都是用链表发解决hash冲突的，而 ThreadLocalMap 采用的是开放定址法。使用均匀的hash算法能够很好地配合开放定址法的工作，避免产生过多的冲突。而涉及到开放定址法肯定会有过期值清理的问题，在ThreadLocalMap中使用了expungeStaleEntry、replaceStaleEntry、cleanSomeSlots三个方法来解决过期值的问题，防止内存泄漏。相较于拉链法来说使用开放定址法可以节省一些指针空间。
看到这里可能有些同学会发现一个问题，get()、set()、remove()方法都对脏数据进行了处理，那么这个脏数据是怎么出现的呢？这个问题就涉及到了弱引用。一个ThreadLocal一般会有两处地方对其进行引用，一个是线程在操作期间对其的强引用，另外一个是ThreadLocalMap对其的弱引用。但是在ThreadLocal中将ThreadLocalMap对其的引用设置为弱引用，因此当线程在操作期间将ThreadLocal的实例强引用设为null，该实例所对应的内存就会被回收，因此entry就存在key为null的情况，无法通过一个Key为null去访问到该entry的value。
key是被回收了，但是value呢？由于此时通过这条引用链：当前线程–>threadLocalMap(线程中的threadLocals)–>entry–>value引用–>value内存。这时候的value无法被GC回收，这样就造成了严重的内存泄漏。因此我们需要在操作get()、set()、remove()方法时都对脏数据进行了处理。
从这里我们可以看出，threadLocal有可能存在内存泄漏，显式地进行remove是个很好的编码习惯，这样是不会引起内存泄漏。
下面我们再看下threadLocalMap的生命周期：
下面是Thread类中的exit()方法，当线程退出时会执行该方法：
private void exit() {
if (group != null) {
group.threadTerminated(this);
group = null;
}
/* Aggressively null out all reference fields: see bug 4006245 */
target = null;
/* Speed the release of some of these resources */
// 这里两段释放了对threadLocalMap的引用
threadLocals = null;
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}
从中我们可以看出，当所有使用了ThreadLocal的线程退出时，ThreadLocalMap的实例便会被GC回收。
74
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
