一：简述
我们很多时候为了实现数据在线程级别下的隔离，会使用到ThreadLocal，那么TheadLocal是如何实现数据隔离的呢？今天就和大家一起分析一下ThreadLocal的实现原理。
二：TheadLocal的原理分析
1.ThreadLocal的存储结构
每个Thread对象中都有一个threadLocals成员变量，threadLocals是一个类型为ThreadLocalMap的map，而ThreadLocal正是基于这个map来实现线程级别的数据隔离的。
我们先看ThreadLocalMap的成员变量
代码语言：javascript复制 //默认的初始化容量大小
private static final int INITIAL_CAPACITY = 16; //Entry数组 真正存储的数据结构
private Entry[] table;
//记录当前元素的数量
private int size = 0;
//扩容的阈值
private int threshold;Entry数组是真正存储数据的地方，可以看出Entry是一个key-value的存储结构，以当前ThreadLocal对象的引用作为key，存储的值为value。Entry继承了WeakReference，并且在构造函数的时候，调用super(k)（也就是WeakReference的构造函数）来对key进行初始化，所以Entry的key是一个弱引用。
代码语言：javascript复制static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) { super(k);
value = v;
}
}根据上面的分析，我们可以知道ThreadLocal的存储结构大概是这样的：
2.源码分析
接下来我们从ThreadLocal的set()，get(),remove()方法为入口对ThreadLocal的源码进行分析。
set()方法
首先判断当前线程的threadLocals是否初始化，如果没有初始化，那么调用createMap()方法进行初始化并设置值，否则调用ThreadLocalMap的set()方法设置值。
流程图：
源码分析：
代码语言：javascript复制public void set(T value) { //利用当前线程获取它的threadLocals（threadLocals是一个ThreadLocalMap）
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t); //如果已经初始化 那么就调用ThreadLocalMap的set()方法
if (map != null)
map.set(this, value); else
// 没有初始化 先进行初始化
createMap(t, value);
}复制代码
ThreadLocalMap getMap(Thread t) { //返回当前线程的threadLocals
return t.threadLocals;
}createMap()
createMap()会调用ThreadLocalMap的构造函数对当前线程的threadLocals初始化，并且初始化Entry数组，然后利用hash算法计算出数组下标，将需要set的值存储在Entry数组。
代码语言：javascript复制void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}复制代码
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { // 初始化Entry数组
table = new Entry[INITIAL_CAPACITY]; //计算数组下标
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1; //设置默认的扩容阈值 和默认容量一样
setThreshold(INITIAL_CAPACITY);
}如果threadLocals已经初始化，直接调用ThreadLocalMap的set()，接下来看ThreadLocalMap的set()方法。
首先利用hash算法计算数组下标，如果计算出的位置没有值，直接将值设置进去，如果存在值（出现hash冲突），分为三种情况：
1.如果key相同，那么直接覆盖值
2.如果计算出的位置的Entry的key为null，那么说明是无效的数据（key为null，entry不为null）,为了避免内存泄漏需要清除这种数据。所以调用replaceStaleEntry()方法将无效数据清除并且将需要设置的值设置到Entry数组中。
3.如果key不相同，而且计算出的位置的Entry的key不为null，那么进入到下一次for循环将计算出的下标 1，（如果到达下标最大值，则设置为0），利用新的位置重新进行判断，直到获取到一个合法的位置（线性寻址法解决hash冲突的问题）。
注：这里大家可以评论区讨论下为什么不和HashMap那样利用链表法解决hash冲突。我个人的看法是因为ThreadLocal的数据量不会像HashMap那么多，所以不需要利用链表和红黑树来解决hash冲突，链表法解决代码相对比较复杂而且扩容迁移数据的数据会比较麻烦。
源码：
代码语言：javascript复制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); //如果出现hash冲突会进入for循环
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get(); //如果key相同 那么直接将值覆盖
if (k == key) {
e.value = value; return;
} //如果key为null 那么说明是无效的数据 需要进行清除
if (k == null) { //调用replaceStaleEntry()方法进行清除数据 并设置值
replaceStaleEntry(key, value, i); return;
}
} //如果没有hash冲突 直接赋值到对应下标的位置
tab[i] = new Entry(key, value); // 将当前元素个数 1
int sz = size; //如果没有需要清除的元素，并且当前元素个数已经达到扩容的阈值，那么进行扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}接下来看replaceStaleEntry()，看ThreadLocal是如何清除无效的数据的。
当前节点是无效的数据，那么周围也可能存在无效的数据，所以ThreadLocal在清除无效的数据时，会顺便清除周围的连续的无效数据，先利用for循环从当前节点向前遍历，调整slotToExpunge的值（slotToExpunge 用于保存开始清除无效数据的下标位置）， 然后向后遍历，如果有entry的key和需要存放的数据的key相同，那么直接覆盖值，并且交换当前节点和新设置的entry的值。
流程图：
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
Entry[] tab = table; int len = tab.length;
Entry e; // slotToExpunge 用于保存开始清除无效数据的下标位置
int slotToExpunge = staleSlot; //从当前位置向前遍历，直到找到一个有效数据的下标
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len)) //e.get()返回Entry的key，威null代表是无效数据
//（因为只有entry不为null才会进入for循环） 所以key为null，就是无效数据
//for循环将清除无效数据的下标往前挪
if (e.get() == null)
slotToExpunge = i; //从当前位置往后遍历
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
//如果遍历的是否发现有和当前Entry相同的key的entry，那么交换两者的位置
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e; //如果slotToExpunge和staleSlot相等
//证明当前节点的前面没有和当前节点连续的无效数据
//所以从交换完的位置开始清除无效数据 调用cleanSomeSlots()方法和expungeStaleEntry()方法清除无效数据 清除完返回。
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return;
} //如果key为null 而且当前entry之前没有与当前节点连续的无效数据
//刷新开始清除无效数据的下标
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
} // If key not found, put new entry in stale slot
//如果没有找到连续的无效数据 把当前的节点的value重置为null 并且将新的值赋值到当前位置
//因为当前的entry是无效的数据
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value); // If there are any other stale entries in run, expunge them
//如果slotToExpunge 和 staleSlot不相等 说明有连续的无效数据需要顺便清除
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}注：大家可以在评论区讨论一下，这里为什么要交换一下数据，我个人认为，第一是为了保证数据存储的位置尽可能的在hash计算出位置，有利于后续的get()方法，第二：交换位置之后有利于让无效的数据连续起来，提高清除无效数据的效率。
真正清除无效数据的方法是expungeStaleEntry()方法和cleanSomeSlots()方法
我们先看expungeStaleEntry()方法
expungeStaleEntry()
expungeStaleEntry()方法从当前节点开始向后遍历（直到遇到enrty为null的节点），将无效数据清除，并且重新计算有效的entry的数组下标，如果计算出的下标和entry的下标不相同（这是因为采用了线性寻址法，所以hash计算出下标可能和实际的下标不一样），重新找到合适的位置。
代码语言：javascript复制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) { //key为null 证明是无效数据 清除
e.value = null;
tab[i] = null;
size--;
} else { //重新计算数组下标 如果数组下标发生变化 那么将数据迁移到新的位置上
int h = k.threadLocalHashCode & (len - 1); if (h != i) {
tab[i] = null; //重新利用线性寻址法寻找合适的下标位置
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
} return i;
}然后是cleanSomeSlots()方法
cleanSomeSlots()
调用log(n)次expungeStaleEntry()方法进行清除无效数据。这个官方说不调用n次来清除，为了效率，而且经过测试调用log(n)次清除无效的数据的效果已经很好了。(n代表entry数组的长度)。
代码语言：javascript复制private boolean cleanSomeSlots(int i, int n) { //removed 是否清除了数据的标记
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;
}如果set()方法设置值之后，需要扩容会调用rehash()方法进行扩容。
先调用expungeStaleEntries()清除一下数据，如果还是需要扩容，那么调用resize()进行扩容。
rehash()
代码语言：javascript复制 private void rehash() { //再试清除一下数据
expungeStaleEntries(); // Use lower threshold for doubling to avoid hysteresis
//如果还是需要扩容 那么会调用 resize()进行扩容
if (size >= threshold - threshold / 4)
resize();
}resize()
resize()方法会创建一个容量为原来两倍的数组，并且将数据迁移到新的数组上面，将新的数组赋值给table变量。（扩容方法比较简单）
代码语言：javascript复制 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 { int h = k.threadLocalHashCode & (newLen - 1); //线性寻址法解决hash冲突
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count ;
}
}
}
setThreshold(newLen);
size = count;
table = newTab;
}get()方法
获取到当前线程的threadLocals，如果threadLocals已经初始化，那么调用getEntry()方法获取值。否则调用setInitialValue()获取我们在initialValue()设置的初始化的值。
代码语言：javascript复制public T get() {
Thread t = Thread.currentThread(); //利用当前线程获取它的threadLocals（threadLocals是一个ThreadLocalMap）
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();
}现在我们看getEntry()方法
如果找到key相同的Entry 直接返回，否则调用getEntryAfterMiss()方法
getEntry()
代码语言：javascript复制private Entry getEntry(ThreadLocal<?> key) { int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i]; //如果找到key相同的Entry 直接返回
if (e != null && e.get() == key) return e; else
return getEntryAfterMiss(key, i, e);
}getEntryAfterMiss()
getEntryAfterMiss()从当前节点往后遍历查找，遍历找到key相同的entry，找到就返回，否则返回null，如果有无效数据，顺便清除一下。
代码语言：javascript复制private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table; int len = tab.length; while (e != null) {
ThreadLocal<?> k = e.get(); //找到key相同的entry 直接返回
if (k == key) return e; if (k == null) //当前数据为无效数据 清除一下
expungeStaleEntry(i); else
//否则向后继续查找
i = nextIndex(i, len);
e = tab[i];
} return null;
}最后是remove()方法
remove()
利用hash算法计算下标，从下标位置开始往后遍历，找到key相同的entry，将entry删除，顺便调用expungeStaleEntry()方法清除一下无效的数据。
代码语言：javascript复制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)]) { if (e.get() == key) {
e.clear();
expungeStaleEntry(i); return;
}
}
}四：总结
本篇文章对ThreadLocal的数据存储结构，以及set()，get()，remove()方法进行了分析。最后给大家可以再讨论一个问题：为什么ThreadLocal的Entry的key要使用弱引用？
