一 前言
在多线程并发的学习中,我们总会接触到一个类,即是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回收。