前言：
ThreadLocal<T>为每个线程提供一个独立的空间，用于存储每个线程自己的变量，多线程并发访问不会出现竞争等并发问题。内部用到了自定义的ThreadLocalMap，但是key值是线程对应的ThreadLocal对象而不是线程本身。
ThreadLocal的本质是让每个线程都持有一个key为该ThreadLocal对象的Map。
这样每次在get或者set的时候直接取线程的该Map通过该ThreadLocal对象（key）对其进行get或者set操作即可。
再往深处挖就会发现Map本质上是一个Entry数组，而Entry持有的key实际上是ThreadLocal对象的弱引用，在ThreadLocal对象的引用变为null时ThreadLocal对象可能被垃圾回收掉，而此时弱引用也会变为null。
我们常用的private static声明的ThreadLocal一般不会被垃圾回收，因此Map可以一直持有该对象。
1、ThreadLocal重要成员
//ThreadLocal本身作为Map的key的hash值，用于存放数据的时候对key的均匀分布
private final int threadLocalHashCode = nextHashCode();
//下一个hash值
private static AtomicInteger nextHashCode =
new AtomicInteger();
//计算下一个hash值的增量
private static final int HASH_INCREMENT = 0x61c88647;
//这是ThreadLocal能存储数据的基础
static class ThreadLocalMap
ThreadLocal的成员变量不多，其中最重要的就是静态内部类ThreadLocalMap了，剩下计算hash值的两个变量我们后续用到的时候再说，这里先留个钩子。
2、ThreadLocal的重要方法
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
get/set方法是我们最常用的方法，方法实现也很简单，取当前线程-->取当前线程关联的Map-->调用Map的put/get/remove方法。着重分析里面的getMap和createMap方法。
//获取Map拿到的是当前线程相关联的ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
ThreadLocal.ThreadLocalMap threadLocals = null;
//创建的Map是内部类ThreadLocalMap
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
这里创建的Map是ThreadLocalMap，其中的Key是ThreadLocal对象本身而不是线程，value是你调用set方法设置的value。
分析到这可以发现问题的关键在于ThreadLocalMap这个内部类：
3、ThreadLocalMap：
3.1、成员变量
//用来存储数据的最小单元，本质上是一个弱引用，在垃圾回收的时候如果对ThreadLocal的引用都是弱引用那么回收该对象
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;
//桶中Entry的个数
private int size = 0;
//下一次扩容的阈值，实际上是我们设定的阈值的2/3
private int threshold; // Default to 0
我们注意到Entry继承了弱引用，对ThreadLocal对象进行了弱引用处理，为什么要这么做呢？实际上Thread类内部有一个成员变量是ThreadLocal.ThreadLocalMap threadLocals = null;Thread之所以持有这个变量就是为了与ThreadLocal进行关联，而Thread持有ThreadLocal.ThreadLocalMap对象之后就会出现一个问题，当Tread线程一直不销毁（比如线程池），那么线程就会一直持有ThreadLocalMap对象，如果ThreadLocalMap里面不使用弱引用，那么Entry里的ThreadLocal对象就会一直存在，有可能造成内存泄漏，而弱引用恰好解决了这个问题，垃圾回收的时候会自动把Entry里的ThreadLocal对象回收掉。
3.2、重要方法（下面文字是对上面代码的解释）
//构造方法，Key为ThreadLocal，该方法就是createmap中调用的方法
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
//新建的时候创建一个Entry桶，长度为16
table = new Entry[INITIAL_CAPACITY];
//取key的hash值然后与容量相与，这样把key均匀的分布到桶的不同位置
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//桶的某个位置存储数据
table[i] = new Entry(firstKey, firstValue);
size = 1;
//设置下次扩容的阈值为16*2/3=10
setThreshold(INITIAL_CAPACITY);
}
上面的方法是构造方法，用于创建一个Map
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
这两个方法用于返回桶的当前位置的相邻位置，值得注意的是桶位置的首尾相连！相当于环形数组！
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);
}
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;
}
该方法用于根据key值获取桶元素，hash到桶位置取出entry对比key值，相同返回。如果对应桶位置没有该key值，沿着环形数组往下找，直到找到为止。
//擦除无效桶位置的无效值
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
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;
}
调用该方法之后首先把对应位置的value值置空并腾出该位置；然后从该位置开始沿着环形桶往后查找，遇到key为空的Entry就清理掉。那么问题来了，什么值才是无效值呢？又为什么会有无效值？前面我们已经了解了Entry继承了弱引用，其中的key值即ThreadLocal是由弱引用包含的，ThreadLocalMap对象内部持有一个Entry【】数组，而数组持有Entry，Entry又持有弱引用ThreadLocal，这样在系统GC的时候Entry的key因为是弱引用就会被垃圾回收掉。因此key有可能为null，即Entry是无效值，需要被擦除。
private void replaceStaleEntry(ThreadLocal key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal k = e.get();
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
该方法用于替换无效值为新插入的值。首先对无效值的桶位置之前的无效桶位置进行标记。之后向后遍历找到key之后将无效位置的Entry与该位置的Entry交换，这样有效Entry位置就提到前面去了。然后从标记的无效位置开始对整个桶做连续的清理工作（将value置空，桶位置置空），注意为O（logn）时间（后面有解释），而前面的替换也是为了进行后面有效的清理（毕竟不是全量清理）。
//set方法
private void set(ThreadLocal key, Object value) {
//取Entry桶
Entry[] tab = table;
int len = tab.length;
//计算key对应的Entry在Entry桶中的位置
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i]; e != null;e = tab[i = nextIndex(i, len)]) {
//取出key值
ThreadLocal k = e.get();
//如果key已存在，那么覆盖更新
if (k == key) {
e.value = value;
return;
}
//如果key值不存在，证明该桶位置的Entry已经被回收，对该位置重新赋值即可。
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//如果桶的对应位置为空，那么把新值加到该位置
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
set方法先直接hash到桶位置，如果桶位置key存在则直接更改其value，如果key不存在说明已经被垃圾回收了，这个时候调用replaceStaleEntry向后查找找到就赋值，找不到就原地赋值，然后从标记的无效位置开始做一次小的清理工作，让有值的Entry尽量连续。这些都完成之后清理一些桶位置。如果没有清理的这些桶位置没有无效值而且当前大小已经超出了负载因子（lenth*2/3）那么再hash并全量清理。
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);
return removed;
}
该方法用于清理一些桶位置，该方法会执行n的位数次，比如n=16（10000）那么执行5次，从当前位置开始向后查找5个位置，如果有无效值就清理出来。为什么这样清理呢，这实际上是一种折中的办法，全量清理花费O（n）时间，不清理不花时间但是垃圾得不到清理，因此使用了O（logn）时间进行清理。该方法有两处调用，一次在replaceStaleEntry，另一次在set方法里。
private void rehash() {
expungeStaleEntries();
if (size >= threshold - 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;
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;
}
rehash方法首先对桶进行了全量清理，即每个位置都扫描清理，耗时O（n）。全量清理之后如果桶中有效Entry个数大于length/2即桶数组的一半长度那么修改桶大小。修改桶大小实际上是扩充了2倍，并且对桶中的位置进行再哈希放到新的桶里面。
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方法显示断开弱引用并清理无效值。
总结：
1、ThreadLocal可能存在内存泄漏问题，因为Entry中的Value值不是弱引用因此可能没有得到回收。所以我们平时使用ThreadLocal的时候应该尽量用完就remove一下，这样可以防止内存泄漏。
2、ThreadLocal在多线程同时set的时候，每个线程都会有一个自己的ThreadLocalMap，即每个线程都会持有ThreadLocalMap中的16位长度的Entry【】数组。
这里留个开放性的问题，ThreadLocal.set(value)的时候设置的是一个值，为什么用16位长度的Entry数组再哈希之后存储该value而不是用一个1位长度的Entry来存储？
3、ThreadLocalMap使用的不是HashMap中的拉链法（当桶位置已经有元素就在元素上使用链表next挂一个元素），而是使用了探针法（当前位置有元素了就探测下一个位置），这样可以边set边清理。
4、有关弱引用和内存泄漏，弱引用WeakReference<ThreadLocal> wr实际上是指wr持有ThreadLcoal对象，但是是弱引用，当GC的时候如果发现对ThreadLocal持有的对象都是WeakReference这种弱引用那么GC会就会回收掉ThreadLocal对象。我们常用的方法是把ThreadLocal当做成员变量放到一个对象里，这样如果该对象不销毁那么ThreadLocal就会一直被一个对象而不是弱引用引用着，因此不会被垃圾回收，如果不调用remove方法就可能造成内存泄漏。就算不是上面这种用法，由于hash表中value不是弱引用，因此也可能出现内存泄漏！
关于第二个问题的解答：
考虑这种情况：
private static ThreadLocal<Integer> tl1 = new ThreadLocal<Integer>();
private static ThreadLocal<String> tl2 = new ThreadLocal<String>();
private static ThreadLocal<Object> tl3 = new ThreadLocal<Object>();
public void amethod(){
tl1.set(111);
tl2.set("Hello");
tl3.set(new Object());
}
当一个线程Thread1执行amethod的时候会调用tl1.tl2.tl3三个ThreadLcoal的set方法，set方法内部调用了getMap，这个getMap返回的实际上是线程Thread1之前创建的ThreadLocal.ThreadLocalMap，即tl1、tl2、tl3三个ThreadLocal是三个不同的key，存放在Thread1线程内部的ThreadLocalMap哈希表里面，一个Entry是存放不下的！
