ThreadLocal源码解读，干就完事了
ThreadLocal 源码
ThreadLocal 提供了线程局部变量，比如我在线程A通过ThreadLocal Set一个值进去，那么在这个线程的执行过程中，我们在任何方法里都能取到这个值。
如果在这个线程中开辟的子线程里面，是取不到这个值的，ThreadLocal只能作用于当前线程。
这就涉及到了ThreadLocal的原理，虽然我们可以在任何地点都能new一个ThreadLocal出来，但是通过ThreadLocal Set的变量最终是存放在当前线程的threadLocals的Map结构中，Map的key是ThreadLocal的实例,我们可以从源码里面看到相关的处理
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
// 如果tab[i]不为空
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 存在引用，直接替换值
if (k == key) {
e.value = value;
return;
}
// 替换过期的k
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 为空，直接存放，增加size
tab[i] = new Entry(key, value);
int sz = ++size;
//检测是否需要调整table大小
if (!cleanSomeSlots(i, sz) && sz >= threshold)
//重新调整大小
rehash();
}
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
// 从当前线程获取 ThreadLocalMap
// 一个Map结构，Key=>ThreadLocal对象，value=>通过ThreadLocal Set进去的值
ThreadLocalMap map = getMap(t);
if (map != null) {
// ***** 核心方法
// 从当前线程的ThreadLocalMap获取Entry,这里的参数this就是当前ThreadLocal对象
ThreadLocalMap.Entry e = map.getEntry(this);
// 不为空就返回
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
// 如果Map为空，这里会创建一个ThreadLocalMap
return setInitialValue();
}
private Entry getEntry(ThreadLocal<?> key) {
// 通过threadLocalHashCode 和 表长度-1 的与运算，得出table的下标
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
// e.get()说明：Entry继承了WeakReference，所以e.get() 获取的是e的引用对象,也就是key
if (e != null && e.get() == key)
return e;
else
// 如果找不到，就从e的位置继续向后找
return getEntryAfterMiss(key, i, e);
}
//查找对象
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
//获取Entry的引用对象ThreadLocal
ThreadLocal<?> k = e.get();
// 相同直接返回
if (k == key)
return e;
// 如果k为空，这是一个过时的数据，执行清理
if (k == null)
expungeStaleEntry(i);
else
// 移动下标，继续查找，一直找到链表的头，如果没有就跳出循环
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
// 清理过期数据，重新计算hash值
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 直接清理过时的数据
tab[staleSlot].value = null;
tab[staleSlot] = null;
//长度减一
size--;
// 继续查找，清理 并 重新计算hash, 直到遇到null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
// 如果为空，就清理，并将size减1
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
// 不为空 ，就重新计算hash
int h = k.threadLocalHashCode & (len - 1);
// 新计算的hash于当前Hash不一致时
if (h != i) {
tab[i] = null;
// 与 Knuth 6.4 算法 R 不同，我们必须扫描直到为空，因为多个条目可能已经过时。
// 如果h位置不为空时，需要重新计算，直到h位置为空
while (tab[h] != null)
h = nextIndex(h, len);
//将i位置的e对象放入h位置
tab[h] = e;
}
}
}
return i;
}
针对threadLocalHashCode的说明
ThreadLocals 的是实现依赖于每个线程中（Thread.threadLocals 和inheritableThreadLocals）的哈希映射。
ThreadLocal 对象充当键，通过 threadLocalHashCode 进行搜索。
这是一个自定义哈希代码（仅在 ThreadLocalMaps 中有用），它消除了在相同线程使用连续构造的 ThreadLocals 的常见情况下的冲突，同时在不太常见的情况下保持良好行为。
InheritableThreadLocal 原理
InheritableThreadLocal 继承了 ThreadLocal
重要的方法
ThreadLocalMap getMap(Thread t) {
return t.inheritableThreadLocals;
}
ThreadLocal 中getMap获取的是Thread.threadLocals 而InheritableThreadLocal 获取的是Thread.inheritableThreadLocals
这就是ThreadLocal和InheritableThreadLocal 最大的不同
如何实现子线程里有父线程的对象？
主要取决与创建线程时的初始化方法
java.lang.Thread#init(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String, long)
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
// 不相干的代码删掉了，不是方法的全部源码
//当前线程，也就是创建线程的线程 = 父线程
Thread parent = currentThread();
//inheritThreadLocals = true,并且父线程的inheritableThreadLocals不为空，就复制到子线程中
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
}
总结：
1.ThreadLocal和InheritableThreadLocal操作的线程变量是不一样的，所以这两个变量的值是不共享。
2.InheritableThreadLocal通过重新getMap的方式，将ThreadLocal中threadLocals替换为inheritableThreadLocals，其他逻辑完全一样。
3.InheritableThreadLocal在子线程创建的时候进行同步，实现代码在Thread#init方法中
4.ThreadLocal的生命周期和Thread一样长，如果不及时remove掉，会造成内存泄漏
