ThreadLocal，顾名思义，肯定是与Thread类有关系的，所以先从Thread类入手。
Thread和ThreadLocal的关联
Thread类中有两个类型为ThreadLocal.ThreadLocalMap的成员变量threadLocals和inheritableThreadLocals，根据注释可知，这两个成员变量是ThreadLocal同当前线程的关联，且是由ThreadLocal类（InheritableThreadLocal类是ThreadLocal类的派生类）维护的。
//Thread
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
/*
* InheritableThreadLocal values pertaining to this thread. This map is
* maintained by the InheritableThreadLocal class.
*/
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
变量的初始化
那么这两个成员变量是什么时候被初始化的？前面说这两个map是由ThreadLocal维护的，说明初始化可能就在ThreadLocal类中。
当线程第一次调用ThreadLocal的set方法或get方法时发现线程的threadLocals变量仍为空，此时就会对其进行赋值，指向一个新建的ThreadLocalMap对象。
//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);
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocal的内部类ThreadLocalMap的结构也是比较简单，其内部维护了一个Entry数组，用于存储ThreadLocal和value值的键值对。Entry继承了ThreadLocal的弱引用，同时内部保存了需要存储的value值。
这里关注一下table表中首次插入索引值的取值方式，取键值的hashCode与table表的容量-1的值相与，得到的即为索引值。
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
......
private Entry[] table;
......
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
而inheritableThreadLocals的初始化则在Thread类的构造函数中，它指向的是一个新建的ThreadLocalMap对象，其内部封装了父线程的inheritableThreadLocals成员变量。
inheritableThreadLocals存储的是父线程中可向子线程中传递的ThreadLocal.ThreadLocalMap。在构造新的ThreadLocalMap对象时，子线程会将parentMap中的所有记录逐一复制到自身的线程。
//Thread
Thread(ThreadGroup group, String name, int priority, boolean daemon) {
......
init2(currentThread());
......
}
private void init2(Thread parent) {
......
if (parent.inheritableThreadLocals != null) {
this.inheritableThreadLocals = ThreadLocal.createInheritedMap(
parent.inheritableThreadLocals);
}
}
//ThreadLocal
static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
return new ThreadLocalMap(parentMap);
}
结合上面的源码，就能理解《java并发编程的艺术》中关于ThreadLocal的解析：
ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构，这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询绑定在这个线程上的一个值。
ThreadLocal的作用
根据以上的存储结构的设计，可以发现：ThreadLocal只是这个存储结构的入口，数据真正是保存在Thread类中的，每个Thread类都指向自己的ThreadLocalMap，从而在线程上实现了数据隔离。
我们可以通过创建不同类型的ThreadLocal对象，通过ThreadLocal的set方法将当前ThreadLocal对象以及要存储的对象打包保存到当前线程中，从而通过不同的ThreadLocal对象以及不同线程的将存储对象隔离开来。
ThreadLocal是为了解决对象不能被多线程共享访问的问题，每个线程使用保存在自身的对象实例，彼此相互隔离，互不影响。
同同步机制对比，同步机制就是通过控制线程访问同一个共享对象的顺序，而ThreadLocal则是每个线程都有一个各自的实例对象，各用各的互不影响，ThreadLocal也可理解为一种“空间换时间”的方式，而同步机制则是“时间换空间”。
ThreadLocal的内存泄露问题
https://www.cnblogs.com/windpoplar/p/11869661.html：
ThreadLocal的实现是这样的：每个Thread 维护一个 ThreadLocalMap 映射表，这个映射表的 key 是 ThreadLocal实例本身，value 是真正需要存储的 Object。
也就是说 ThreadLocal 本身并不存储值，它只是作为一个 key 来让线程从 ThreadLocalMap 获取 value。
值得注意的是图中的虚线，表示 ThreadLocalMap 是使用 ThreadLocal 的弱引用作为 Key 的，弱引用的对象在 GC 时会被回收。
ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用来引用它，那么系统 GC 的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。
既然泄漏是因为使用了弱引用导致的，那为何还要使用弱引用？
若ThreadLocal使用的是强引用，当ThreadLocal外部强引用被清除时，ThreadLocalMap内部的Entry仍强引用ThreadLocal对象，导致GC回收时ThreadLocal仍有强引用，导致无法清除。
所以每次使用完ThreadLocal，调用其remove方法及时清除关联的数据。
ThreadLocalMap的插入（冲突的解决以及脏数据处理）
当ThreadLocalMap非空后，就会调用其set方法来插入新的Entry对象。这里关注一下当冲突发生的解决方式：当通过键值的hashCode与容量-1的值相与得到的索引位置非空时，如果该索引对应的Entry对象的键值与当前键值相同，则直接替换value值，若Entry对象的键值为空，则调用replaceStaleEntry方法进行替换（这里即为脏数据的处理过程）；否则则当前索引值加1，重复判断，或新的索引位置为空，则直接插入。
显然，一个ThreadLocal对象在一个ThreadLocalMap中只能对应一个值。
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);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
上面提到replaceStaleEntry方法是用于处理脏数据的，当查找到键值为null的Entry时，说明已经有过GC了，此时会通过replaceStaleEntry方法及时清理部分键值为null的数据，该方法也是解决内存泄漏的一种优化。
具体的处理细节可以参考这篇文章，里面结合图及例子讲得挺全的。
