上文我们学习了ThreadLocal的基本用法以及基本原理，ThreadLocal中的方法并不多，基本用到的也就get、set、remove等方法，但是其核心逻辑还是在定义在ThreadLocal内部的静态内部类ThreadLocalMap中，里面有很多设计非常精妙的地方，本文中我们就从ThreadLocalMap的角度入手深入学习ThreadLocal的原理。
1. 基本数据结构
按照官方的解释是：这是一个定制化的Hash类型的map，专门用来保存线程本地变量。其内部采用是通过一个自定义的Entry来封装数据，并且保存在一个Entry数组中。为了便于处理大量且长时间存活的对象引用(其实是ThreadLocal)，Entry采用WeakReference作为key的类型，当map中空间不够时，key为null的ertry将会被删除。ThreadLocalMap内部数据结构如下：
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** 要保存到线程本地的变量 */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
/**
* 数组初始容量 -- 必须为2的倍数.
*/
private static final int INITIAL_CAPACITY = 16;
/**
* 存储entry的数组，长度为2的倍数
*/
private Entry[] table;
/**
* entries数量
*/
private int size = 0;
/**
* resize阈值
*/
private int threshold; // Default to 0
/**
* 计算阈值
*/
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
/**
* i+1，大于等于len则从0开始继续
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
/**
* i-1，小于0则从len-1开始继续
*/
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
......
}
在ThreadLocalMap内部通过自定义的Entry类来封装要保存的数据，以ThreadLocal类型对象为key，Object类型对象为value。这个Entry继承自WeakReference<ThreadLocal<?>>，每个Entry都可以是一个指向ThreadLocal对象的弱引用，可通过Entry的get方法来获取对ThreadLocal对象的引用，而这个引用就是key。所有的Entry统一保存在一个Entry数组table中，数组的长度必须为2的倍数，通过key的hashcode与数组长度减1进行与运算来定位Entry在数组中的存储位置，这点和hashmap类似，但是当发生hash碰撞时hashmap的处理方法是放入链表或者树中(都在同一个hash桶中)，而ThreadLocalMap则是依次往后查找可以保存的地方，没有桶的概念(这点后面会结合代码详细讲)。
既然ThreadLocalMap内部是一个数组，通过key的hashcode来定位到数组下标，这里我们不得不说一下key的hashcode的生成方式，非常精妙，因为key类型为ThreadLocal，所以其hashcode的生成方式也在ThreadLocal中：
private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
对于每个ThreadLocal对象，都有一个独自不变的hashcode，每新增一个ThreadLocal对象，会自动生成其自己的hashcode，其实就是让nextHashCode自增0x61c88647，目的是为了让生成的hashcode均匀的分布在2的幂次方上，而数组长度也是2的幂次方，这样就保证了要插入的元素可以均匀分布在数组中。
虽然ThreadLocal使用了很牛逼的办法来生成hashcode，但是还是不可避免会产生hash碰撞，当出现碰撞时是如何来处理呢？我们接着看：
2. 获取元素
我们知道ThreadLocalMap是以Entry为基本单元保存数据的，而且是以key-value对的形式，我们先来看一下是如何通过key获取到Entry的：
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);
}
这个逻辑比较简单：
- 首先通过key的hashcode获取数组下标(与运算)；
- 如果下标对应处Entry不为空，且key与传入的key是指向同一个ThreadLocal对象则认为找到，直接返回Entry；
- 否则执行getEntryAfterMiss；
/**
* 有三种情况下会执行这个方法
* 1. e为null；
* 2. e!=null，e的key=null；
* 3. e!=null，e的key!=null，e的key!=要找的key，即出现hash碰撞
**/
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];
}
return null;
}
这里的逻辑也比较清晰：
- 获取内部保存Entry的数组及数组长度；
- 获取传入Entry对应的key，如果和传入的key相等则直接返回key；
- 如果Entry对应的key为空，则执行expungeStaleEntry，传入的参数为当前Entry所在数组下标i；
- 否则将获取e在数组中后面那个元素并赋值给e，如果e不为空，则循环从第2步执行，否则直接退出循环；
对于key为空的Entry在ThreadLocal里面称为staleSlot，接下来看一下expungeStaleEntry：
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 直接将下标为staleSlot处的元素擦除，value和Entry都要擦除
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash操作直到数组对应下标处元素为空的情况
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 {
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;
}
逻辑会稍微复杂一些，我们还是一步一步看：
- 获取内部保存Entry的数组及数组长度；
- key为空代表这个Entry已经不需要了，直接置空，帮助gc，并将size减1；
- 从传入的staleSlot下标后面的元素开始，依次遍历过去，循环执行下面的操作，直到遇到Entry为空停止；
- 如果Entry为staleSlot(即key为null)，则清空；
- 否则检查该Entry是否在它应该在的位置(根据hashcode计算出来的下标与其实际下标是否相等)；
- 如果不在则将当前slot置为空，继续往后寻找，直到一个Entry为空的slot，将其放进去，重复下一次循环；
expungeStaleEntry的作用是清除传入的staleSlot处的Entry，除此之外还会管两件"闲事"：
- 从其后面开始清除遇到的staleSlot；
- rehash计算下标与实际下标不相符的Entry，
- 直到遇到Entry为空的slot则停止。
从上面的分析我们得出，通过key获取元素时，如果从计算出来的下标能获取到符合要求的值则直接返回，否则会从该位置开始依次往后找；遇到Entry不为空但是Entry的key为空的会擦除该Entry并继续循环；遇到Entry不为空且key不为空(hash碰撞)则直接往后找；在整个找的过程中遇到Entry为null则停止查找，直接返回null。
3. 设置元素
接下来我们看看设置元素，也就是set方法：
private void set(ThreadLocal<?> key, Object value) {
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;
}
// 发现staleSlot，则执行replaceStaleEntry，然后直接返回
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 如果没有找到，则new一个Entry插入数组中
tab[i] = new Entry(key, value);
int sz = ++size;
// 插入新的Etry之后需要试探的去擦除一些过期的slot(key=null的Entry)，如果Entry数量大于阈值，则执行扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
这也是一个私有方法，这里看起来代码不多，但是里面涉及到的东西很多，逻辑也要比get方法复杂，但是没关系，我们层层递进，一一分解。
- 获取Entry数组、数组长度以及通过要插入的key的hashcode计算出其在数组中的下标；
- 拿到下标之后，对应下标处如果有Entry存在，则有三种情况：
- key不为空，且等于要插入的key，则直接将value替换成要执行的value，返回；
- key为空，则执行replaceStaleEntry中的逻辑，返回；
- 如果key不为空但是又不等于要插入的key，则取下标i处后一个元素，循环执行上面的操作；
- 如果如上的循环结束，到这里代表没有找到要插入的key，且当前i处的Entry为空，则直接new一个Entry，将待插入的key和value放入其中，再放入数组；
- 将代表数组中Entry数量的size加1；
- 执行cleanSomeSlots中的逻辑，如果有删除一些Slot，并且size大于阈值，则需要执行rehash中的逻辑进行扩容，否则set执行结束；
上面的步骤看完之后，我们来看看其中当key为空时需要执行的replaceStaleEntry的逻辑：
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// 现在staleSlot处对应的Entry其key=null，往前查找看是否能不能找到一个stale的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();
// 找到了直接替换，替换之后再尝试删除一些stale的Entry
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// Start expunge at preceding stale entry if it exists
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
// 如果i处对应的Entry是stale，并且前面往前没有找到stale的Entry，则将i标识为待擦除的slot
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// 如果没有找到传入key对应的entry，则new一个新Entry放在传入staleSlot下标处，现在staleSlot处的Entry不再是stale(过期的)了
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// 如果还发现有其他stale entries存在, 将其清除
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
这个replaceStaleEntry的逻辑比较难理解，只要清楚它主要干了下面两件事：
- 尝试查找和传入key对应的Entry，找到则替换，没找到则在传入的staleSlot处插入一个新的Entry；
- 在上面的过程中，尽力地去擦除一些找到的staleSlot；
以及插入一个新的Entry之后，试探性地去删除多余的staleSlot(注意，是试探性的哦)，逻辑在cleanSomeSlots中：
/**
* @param i 扫描起始下标，从第i+1处开始扫描
*
* @param n 扫描次数控制量，在往后面扫描的过程中，如果没有发现staleSlot，则最多扫描log2(n)个元素，否则在staleSlot之后再扫log2(table.length-1)个
**/
private boolean cleanSomeSlots(int i, int n) {
// 标识是否有删除过staleSlot
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;
}
从i+1处开始，往后扫描，如果遇到staleSlot，则执行expungeStaleEntry，往后扫描log2(n)次结束循环，n为传入的参数，如果发现staleSlot，则将n更新为Entry数组长度len。
这个设计非常巧妙，试探性的扫描一些单元看是否能发现staleSlot(不新鲜的entrys，也就是key=null)。当一个新元素添加进来或者一个staleSlot被清除的时候，会调用这个方法。该方法扫描元素的数量是对数级的，如果不扫描就不能及时清除key为null的entry(会浪费内存)，如果全数组扫描则会导致一次插入的时间复杂度为O(n)，采用这种试探性的扫描方式其实是一种在功能和性能之间的平衡，尽最大努力清理垃圾，又不导致过于消耗性能。
如果插入了新Entry，且执行了cleanSomeSlots之后size的数量还是大于阈值的话，这时就需要rehash扩容了：
private void rehash() {
expungeStaleEntries();
// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4)
resize();
}
// 扫描全表，清除所有staleSlot
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) {
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;
}
首先扫描全表，清除所有staleSlot，如果这还不能减小size，则将table容量扩大一倍。扩容的逻辑比较简单，根据新数组容量来计算新的数组下标，如果存在hash冲突就往后找，直到Entry为空则把元素放进去。
到这里我们学习了ThreadLocal的基本原理、核心数据结构、最常用的get和set方法，是不是对ThreadLocal有了更深入的了解呢？如果有，那非常高兴我的文章能给你带来一丁点价值^_^
4. 内存泄漏
前面有讲到，ThreadLocalMap中的Entry其类型是属于弱引用(继承了WeakReference)，被弱引用指向的对象，在下一次GC时是会被回收的，除非这个对象还有强引用指向它(对Java中强、软、弱、虚引用不清楚的同学可以详细了解下)，之所以这样设计，我的理解是Entry是存在ThreadLocalMap中，而这个map又是保存在线程thread中的，用户是不能直接获取到的，也是不能直接操作的，也就会影响到垃圾回收。为了避免因为ThreadLocalMap存储了ThreadLocal对象而影响到ThreadLocal对象的垃圾回收，JDK的设计者把主动权完全交给调用方，一旦调用方不想使用，只需设置ThreadLocal对象为null，内存就可以被回收掉了，这也是弱引用的一个主要使用场景。
另一方面，在set和getEntry的过程中会频繁的去清理stale entry，以及时释放空余位置，这样就可以及时清除value，因为value是我们要保存到ThreadLocal中的值，而这是强引用，即便是key被回收了，value依然不会被回收。
虽然ThreadLocal中做了种种设计来防止内存泄漏，但是如果使用不当还是会导致内存泄漏，我这里借用一个网上的例子，一起来感受下：
public class ThreadLocalLeakDemo {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0; i< 1000 ;i++) {
TestClass t = new TestClass(i);
t.printId();
// 行1，注释掉这一行时不会导致内存溢出
t = null;
// 行2，注释掉这一行时会导致内存溢出
t.threadLocal.remove();
}
}
}).start();;
}
static class TestClass{
private int id;
private int[] arr;
// 注意，这是一个普通成员哦
private ThreadLocal<TestClass> threadLocal;
TestClass(int id){
this.id = id;
arr = new int[1000000];
threadLocal = new ThreadLocal();
threadLocal.set(this);
}
public void printId() {
System.out.println(threadLocal.get().id);
}
}
}
/**
* 注释行2，放开行1时，会导致内存溢出，结果如下：
**/
...
449
450
451
Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space
at testDemos.annotationDemos.ThreadLocalLeakDemo$TestClass.<init>(ThreadLocalLeakDemo.java:28)
at testDemos.annotationDemos.ThreadLocalLeakDemo$1.run(ThreadLocalLeakDemo.java:13)
at java.lang.Thread.run(Unknown Source)
...
/**
* 注释行1，放开行2时，不会导致内存泄漏，结果如下：
**/
...
997
998
999
上面其实就是改了一行代码，就导致内存溢出，增加的那一步操作就是调用了ThreadLocal的remove，那我们就来看看remove的逻辑：
移除元素的逻辑很简单，根据传入的key定位到数组下标i，从这个下标开始往后循环，直到遇到Entry为空时停止循环。如果找到key对应的entry，则调用Entry的clear方法。
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;
}
}
}
结合上面的例子和源码，我们解释一下为什么没有调用remove方法会导致内存溢出。如上，在不调用remove时，每一次循环都会插入一个新的Entry对象到ThreadLocalMap中，这个Entry是指向一个新的ThreadLocal对象，对于这个ThreadLocal对象存在两个引用：
- Entry-->ThreadLocal，这是弱引用；
- Entry-->value(TestClass)-->ThreadLocal，这是强引用；
由于强引用一直存在，而t=null并不能让value不可达，因为value是保存在线程本地内存中的，所以没法回收这个新的ThreadLocal对象，导致一直堆积，最终报OOM
而如果调用remove的话，则会直接将对应Entry以及其保存的value清空，这样就不会内存泄漏了。
其实上面的例子是使用不当导致的，如果将ThreadLocal成员变量置为static，也不会出现这个问题，因为即便有1000次循环，但是都是用的同一个ThreadLocal，在线程本地始终只有一份，用private static来修饰ThreadLocal也是一个官方推荐的惯用法。
5. 总结
- ThreadLocal内部数据结构：Entry数组
- Entry封装要保存的数据，以key-value的形式，key的类型为指向ThreadLocal的WeakReference，value为要保存的对象
- 通过key的hashcode来初步定位其在数组中的位置，如果没有则往后依次查找，如果找到则返回(getEntry)或替换(set)，直到碰到为空的Entry为止，这就是解决hash碰撞所采用的方法；
- 当出现hash冲突时，ThreadLocalMap采用的办法就是继续往后面找，这是线性操作所以会比较低效。但是ThreadLocal采用的散列算法效果很好，冲突的概率非常小，再加上在set和getEntry的过程中会频繁的去清理stale entry(expungeStaleEntry、replaceStaleEntry、cleanSomeSlots中都有涉及到)，是为了能够及时释放空余位置，进一步降低这种低效带来的影响。
- 由于Entry是指向ThreadLocal对象的弱引用，所以当ThreadLocal对象不存在强引用的时候，是可以被回收的，回收之后Entry就指向空了(get获取的key为null)，但是这时候Entry中的value仍然不为空，可以可能导致内存泄漏，有两种方式可以清除：
- 在ThreadLocal的get、set方法中会频繁的去清除staleSlot
- 手动调用TreadLocal的remove方法来清除
以上为个人总结，如有不对，烦请指正。