在之前的博文【JavaEE】关于ThreadLocal和模态框的关闭中，我们曾经用到过ThreadLocal，当时对于ThreadLocal的理解是我们可以将两个彼此毫无关系的线程之间建立关系。但是这到底是怎么实现的？现在让我们来对它的源码进行一下探究。
首先，可以看到，ThreadLocal类是一个泛型类：
public class ThreadLocal<T> {
……
}
所以，我们在使用它的时候，必须要给<>里面增加一个类型。
我们之前使用它的时候，是在某一个线程中通过无参构造，然后覆盖initialValue()方法，再在另一个线程里面通过get()方法，得到initialValue()方法返回的实例对象。那么我们进而来看一下这两个方法的源码。
initialValue()方法：
protected T initialValue() {
return null;
}
这个方法是被protected所修饰的，那么它自然是可以被继承的，而它的返回值类型是一个泛型，也恰好是ThreadLocal这个泛型类的类型，那么我就可以在外面定义任意的类型，然后将它作为泛型，然后通过initialValue()方法，将这个类型的实例对象进行返回。
再看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()方法的返回值类型同样是一个泛型，然而，它return的却是一个setInitialValue()，并且，没有任何的参数传进去，那么我们就可以先"忽略"(后面我们会对这些代码进行详细分析)中间的代码，直接看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;
}
不用说这个方法的返回值必定是泛型类型。它返回的value是和initialValue()方法有关，并且又没有传参，value的值在中间的代码里面也没有任何的修改，initialValue()方法在之前我们已经看到过它的源代码，它就是返回一个泛型类型。所以，到这里，我们可以明白，为什么我们之前对于ThreadLocal的使用，通过initialValue()方法和get(）方法可以得到一个泛型类的对象，原因正是因为我们在new的时候通过覆盖initialValue()方法返回了它的对象，然后在get()方法调用了initialValue()的返回值，也等于是直接进行了返回，所以我们可以得到这个对象。
事实上，我们在get()方法中，可以看到有两个if判断，如果全满足，会返回一个结果。我们之前的做法，其实是get()方法中的一种情况，这种情况其实对应了我们没有对ThreadLocal这个类进行过任何的 set 等操作，所以，队员两个if都是不满足的，直接返回了我们最初initialValue()方法的结果。那接下来，我们从set方法开始进行分析，之后再重新分析一下get()方法的另外一种情况。
set方法(单参)：
public void set(T value) {
// 通过native方法，获得当前的线程
Thread t = Thread.currentThread();
// 再得到该Thread对象的ThreadLocalMap成员 map
// 如果从来没有进行过set，那结果肯定是null
ThreadLocalMap map = getMap(t);
// 判断map是否为null
if (map != null)
// 若不为空，需要调用map的set()方法
map.set(this, value);
else
// 若map为空，需要先执行createMap()方法，初始化ThreadLocalMap
createMap(t, value);
}
上面提到了很多之前没没提到的内容，现在来一一讲解：
Thread类，
public
class Thread implements Runnable {
// 其中，众多成员中，这个成员和我们的ThreadLocal是很相关的。
// 它的类型是ThreadLocal.ThreadLocalMap类型，可见ThreadLocalMap是ThreadLocal的内部类
ThreadLocal.ThreadLocalMap threadLocals = null;
……
}
我们再来看一下ThreadLocalMap这个内部类：
static class ThreadLocalMap {
// Entry继承WeakReference，并且用ThreadLocal作为key
// 如果它的get()返回值为空，那么表明对象已经被回收了，也就是可以重复对这个空间赋值
// 关于WeakReference类的详细解析，请看我转载的这篇博文(https://www.cnblogs.com/zjj1996/p/9140385.html)
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// 数组的初始容量
private static final int INITIAL_CAPACITY = 16;
// 一个节点数组
private Entry[] table;
// 存放的节点个数
private int size = 0;
// 阈值
private int threshold;
现在可以明确的是，对于Thread类，每一个Thread类都会有一个ThreadLocalMap ，来存放多个线程本地变量。
以上是这个类的成员，可以看到，这些成员与HashMap里面的成员有很多是相同的(但是这里没有写出来负载因子)，那么它的存储结构也应该有很多相似地方，我们继续往下看。
getMap()方法:
ThreadLocalMap getMap(Thread t) {
// 返回的是t线程的ThreadLocalMap
return t.threadLocals;
}
createMap()方法：
void createMap(Thread t, T firstValue) {
// 调用了ThreadLocalMap的构造方法
// 把自己和一个泛型对象传进去
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 因为是第一次创建ThreadLocalMap对象，所以要先初始化table数组
table = new Entry[INITIAL_CAPACITY];
// 这一步操作和HashMap根据哈希值确定数组下标有些像，
// 都是和(长度-1)进行相与，其结果作为数组的下标值
// 而这里的threadLocalHashCode，其实是调用了AtomicInteger类的getAndAdd()方法
// AtomicInteger提供原子操作来进行Integer的使用，因此十分适合高并发情况下的使用
// https://www.cnblogs.com/zhaoyan001/p/8885360.html
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 将键和值放到一个Entry节点中，并将节点放到数组中
table[i] = new Entry(firstKey, firstValue);
// 因为只放了一个，所以当前长度为1；
size = 1;
// 设置阈值
setThreshold(INITIAL_CAPACITY);
}
private void setThreshold(int len) {
// 在HashMap中，阈值等于加载因子*capacity(数组容量)
// 那么，这里的加载因子就是 2/3(HashMap中是0.75)
threshold = len * 2 / 3;
}
这时，对于第一个泛型类型的value就已经set好了；那如果设置第二个value的时候，因为ThreadLocalMap 已经初始化过了，将会执行map.set(this, value);这个方法。现在来分析一下这个方法：
// 这个方法是在ThreadLocalMap 里面的
private void set(ThreadLocal<?> key, Object value) {
// 下面这个英文注释已经表明，set方法并没有像get()方法那样快速
// 后面我们会对get方法进行分析
// 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.
// 给tab赋值
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;
}
// 如果键为null，说明被回收了
// 这个时候说明改table[i]可以重新使用，
// 用新的key-value将其替换,并删除其他无效的entry
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 只要循环结束，那就表明在当前下标的值为null，直接重新生成一个节点并插入
tab[i] = new Entry(key, value);
// 当然节点数要增加
int sz = ++size;
// 开始进行清除，因为有的数组空间，它自己不为null，但是他的get()方法为null，
// 也就是上面的if(k == null)，将这些空间进行清理
if (!cleanSomeSlots(i, sz) && sz >= threshold)
// 如果没有清理，检测当前存储的值是否超过阈值，进行扩容
rehash();
}
上面代码有写道nextIndex()方法，replaceStaleEntry()，cleanSomeSlots(）,rehash()方法后面我们一一解析。先看nextIndex()方法，它和prevIndex()方法是对应的。
private static int nextIndex(int i, int len) {
// 判断当前下标加一(也就是后一个下标)是否超过数组长度，
// 没有超过就返回，超过就从下标为0开始
return ((i + 1 < len) ? i + 1 : 0);
}
private static int prevIndex(int i, int len) {
// 判断当前下标减一(也就是前一个下标)是否小于0，
// 没有，就返回，小于了就从数组最末尾开始
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
其实，这两个函数，目的就是为了解决hash冲突，然后对数组进行了一个遍历，包括从前遍历和从后遍历两种。这也就是所谓的线性探测法。可以看到，这种方法的缺点就是假如数组特别长，其中为null的数组特别少，那么遍历起来是费时间的。画个图表示：
再看replaceStaleEntry()方法：
// 替换不新鲜的Entry
// 这个函数，源码已经给了英文解释
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// 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;
// 从当前开始，从前遍历，直到找到第一个null数组，
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();
// 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，进行赋值，
// 并且将当前值与最开始的tab[staleSlot]值进行替换，
// 在这里可能有人会有个疑问，
// 为什么key相等，不在原来hash值对应的下标存放，反而要到这个位置来存放？
// 原因很简单，在set方法中，我们是从hash值计算得到对应的下标开始遍历的
// 假如，那个下标有值了，那么不得不更换位置进行存储，所以找到了一块已“失效”的空间
// 这也是为了避免浪费，将“失效”的空间利用起来
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// Start expunge at preceding stale entry if it exists
// 如果向前查找没有找到(e.get() == null)的节点，
if (slotToExpunge == staleSlot)
// 令要抹去的为当前i
slotToExpunge = i;
// 进行清除工作
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.
// 如果当前的节点(e.get() == null)，
// 并且向前查找没有找到(e.get() == null)的节点
if (k == null && slotToExpunge == staleSlot)
// 那么令要抹去的位置为i；
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
// 最开始slotToExpunge与staleSlot 的结果是相等的，进行了两次遍历
// 若slotToExpunge != staleSlot,说明存在其他的无效entry需要进行清理。
if (slotToExpunge != staleSlot)
// 开始进行清理
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
然后我们进行cleanSomeSlots()函数的解析：
// 清理工作
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);// 从这里可见，n表示了循环的次数
// 返回是否进行了清理
return removed;
}
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
// 对传入过来的数组元素进行清楚
tab[staleSlot].value = 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) {
// 表明是“无效”节点，需要进行清除
e.value = null;
tab[i] = null;
// 存入的节点的长度也要跟着减
size--;
} else {
// 检测一下当前的key的hash值与数组长度-1的结果h是否和当前元素的下标i相等
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
// 不相等，立马将i设置为null
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
// 开始寻找这个h，如果数组为h的不等于null(表明已经存放了别的值)
// 那就继续遍历，找到为null的下标
while (tab[h] != null)
h = nextIndex(h, len);
// 将下标存入
tab[h] = e;
}
}
}
// 返回下一个为null的solt的下标。
return i;
}
rehash()方法源码：
private void rehash() {
// 它先调用了expungeStaleEntries()方法
// 先对数组作清理工作
expungeStaleEntries();
// Use lower threshold for doubling to avoid hysteresis
// 因为阈值 threshold = len * 2 /3
// 经过换算 threshold * 3 / 4 = len / 2
// 在HashMap中，当size = threshold 的时候就要进行扩容，
// 而这里应该是把这个阈值变得更小了，
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);
}
}
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) {
// 直接将原数组的值设置为null
// 可以看到，在源代码的注释中也写出了注释： 帮助垃圾回收机制
e.value = null; // Help the GC
} else {
// 执行到这里，说明数组中存的是有效元素
// 重新计算下标的位置，
int h = k.threadLocalHashCode & (newLen - 1);
// 通过下标h，进行检测，是否存了数据，
while (newTab[h] != null)
// 如果存了，那就继续寻找为null的
h = nextIndex(h, newLen);
// 找到后，进行数组的赋值
newTab[h] = e;
// 新数组中的有效节点个数加一
count++;
// 继续循环遍历
}
}
}
// 根据当前新数组的长度，更改阈值
setThreshold(newLen);
// 设置新数组的有效节点数
size = count;
// 将新数组赋值给成员table
table = newTab;
}
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
这时，我们可以再来看get方法：
public T get() {
Thread t = Thread.currentThread();
// 获取在对应线程中的ThreadLocalMap实例
ThreadLocalMap map = getMap(t);
// 检测是否为null
if (map != null) {
// 获取该ThreadLocal所对应的Entry实例
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
private Entry getEntry(ThreadLocal<?> key) {
// 通过传过来的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);
}
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)
return e;
if (k == null)
// 找到一个“失效”节点，直接进行清除
expungeStaleEntry(i);
else
// 下标向下一位移动
i = nextIndex(i, len);
// 继续进行遍历
e = tab[i];
}
// 表明没有找到，返回null
return null;
}
最后看remove()方法：
// 移除某个节点
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) {
// 如果key一样，不管是不是“有效”,全部进行清除
e.clear();
expungeStaleEntry(i);
return;
}
}
}
最后看remove就相对简单很多了。
综合来说，上面的很多方法其实都是ThreadLocalMap的内部的方法，因为一个Thread对应一个ThreadLocalMap，而ThreadLocalMap是ThreadLoacl的一个内部类。ThreadLocal的好多方法的实现正是调用ThreadLocalMap，因为他们彼此之间都是唯一的。
存储结构，它采用的是线性探测法解决hash冲突。对于它的存取过程而言，和HashMap一样，会先进行，数组的定位，然后再具体定位，定位之前也是先进行判断，如果遇到“无效”的，直接进行删除。而且，它在很多时候，不论是存还是取，都不忘记去及时清理“无效”节点，这是我编程的最大的收获。
1313
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
