一 ThreadLocal定义
ThreadLocal是线程局部变量，是一种保存线程私有信息的机制。
通过 ThreadLocal 可以为每个线程提供线程独有的变量拷贝，用来保证每个线程间访问的变量互不影响，这种变量只在线程的生命周期中起作用，在本线程内随地可取可用，以减少同一个线程内多函数间变量传递的复杂度。
ThreadLocal是用来解决java多线程程序中并发问题的一种方式，除ThreadLocal外，我们也可以通过加锁(eg: synchorinized )的机制来保证变量的线程安全性，但加锁会影响到程序的执行效率，此时ThradLocal就可以派上用场；
二 使用场景
1、Spring事务隔离基于 ThreadLocal 和 AOP 实现，具体源码参见 TransactionSynchronizationManager；
2、Spring使用 ThreadLocal 来保证单个线程中的数据库操作使用的是同一个数据库连接；
3、session管理；
4、业务中涉及横跨多方法、多层级调用时将请求参数放入ThreadLocal，防止过渡传参，如用户id 从controller 透传到 dao层等；
5、基于ThreadLocal 实现 SimpleDateFormat 线程安全性；
6、... ...
三 API
// 获取当前线程中的共享变量的副本
public T get() {}
// 设置当前线程中变量的副本值
public void set(T value) {}
// 移除当前线程中变量的副本，回收内存；
// 其实这个不是必须要调用的，因为当线程失效之后，这些内存会自动释放
// 未避免出现内存泄露问题，建议在线程结束前手动调用该方法清空数据
public void remove() {}
// get调用时的默认值，默认返回null
// protected方法；方便实际业务中根据实际需要重写方法
protected T initialValue() {}
调用示例：
ThreadLocal<String> tl = new ThreadLocal<>();
tl.set("zhangsan");
System.out.println(tl.get());
tl.remove();set()
源码示例：
public void set(T value) {
Thread t = Thread.currentThread(); // 获取当前线程
ThreadLocal.ThreadLocalMap map = getMap(t); // 获取当前线程 ThreadLocalMap 对象
if (map != null)
map.set(this, value); // 不为空则set
else
createMap(t, value); // 为空则初始化当前线程 ThreadLocalMap
}set()方法实现比较简单，主要关注其中的 ThreadLocalMap 对象，ThradLocalMap对象是获取自当前线程的一个 threadLocals 变量：
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}public class Thread implements Runnable {
... ...
/* 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;每个线程维护了自己的 threadLocals，在线程创建 TreadLocal 及保存变量时，实际上变量是存在于当前线程自己的threadLocals变量里的，其他的线程自然无法获取当前线程的变量，也就实现了数据隔离；
再来看看ThreadLocalMap：
static class ThreadLocalMap {
// 基于弱引用的Entry对象
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// 初始容量 默认16
private static final int INITIAL_CAPACITY = 16;
// 数组结构存储数据
private Entry[] table;
/** The number of entries in the table. */
private int size = 0;
/** The next size value at which to resize. */
private int threshold; // Default to 0
// resize门限 2/3
private void setThreshold(int len) {
threshold = len * 2 / 3;
}由上述源码也可以看出，ThreadLocal并没有存储任何值，它只是用来当ThreadLocalMap的key，让线程可以拿到对应的value。
ThreadLocalMap中有个Entry数组，之所以用数据是因为一个线程中可能存在多个不同的ThreadLocal来存储不同的对象，所以此处用数组来存储；
ThreadLocalMap的数据结构有点像HashMap，但它并没有实现Map接口，而且他的Entry继承了 WeakReference 弱引用，也没有HashMap中的next，所以也就不存在链表，因此当存在hash冲突时，ThreadLocalMap采用线性探测的方式来解决hash冲突。参见源码：
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();
// 如果当前位置不为空，且key即为当前threadlocal，则刷新value
if (k == key) {
e.value = value;
return;
}
// 如果当前位置为空，则初始化一个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();
}ThreadlocalMap在set元素时会先获取key即当前ThreadLocal的threadLocalHashCode，并根据threadLocalHashCode的值定位到元素在table中的位置：
1、如果当前位置为空，则初始化一个Entry对象放在当前位置上；
2、如果当前位置不为空，且key即为当前threadlocal，则刷新value;
3、如果当前为空不为空，且key不为当前threadlocal，则继续迭代table，寻找下一个空位置；
get()
源码示例：
public T get() {
Thread t = Thread.currentThread();
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();
}
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;
// 根据key的hashcode获取在table中的下标值，循环查找元素对比key是否相等
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;
}与set()类似，同样是先获取到当前线程的ThreadLocalMap，然后在 map.getEntry()中通过 threadlocal 的 threadLocalHashCode定位到当前 threadlocal 在table中的位置，循环查找元素对比key，捞取数据；
内存泄露问题
回到ThreadLocalMap的Entry对象，上面提到Entry对象继承了 WeakReference 弱引用，参见弱引用的定义：
弱引用（Weak Reference）：弱引用的对象拥有更短暂的生命周期。
在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，
不管当前内存空间足够与否，都会回收它的内存这就导致一个问题，即当前 threadlocal 在没有外部引用的时，如果此时触发GC，则Entry的key即threadlocal会被回收， 而如果创建当前Theadlocal的线程一直运行，则Entry的value对象有可能一直得不到回收，久而久之就有可能产生内存泄露；
所以为了避免产生上述内存溢出问题，在使用threadlocal需记得在线程代码最后调用 ThreadLocal 中的 remove() 方法将值清空，这样在触发GC时就会将值回收掉，避免内存泄露；
父子线程共享ThreaLocal
java.lang.Thread中提供了 inheritableThreadLocals 属性用以支持获取父线程线程变量
/*
* InheritableThreadLocal values pertaining to this thread. This map is
* maintained by the InheritableThreadLocal class.
*/
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;代码示例：
public static void main(String[] args) {
ThreadLocal<String> tl = new InheritableThreadLocal<>();
tl.set("zhangsan");
Thread child = new Thread() {
@Override
public void run() {
super.run();
System.out.println(tl.get());
}
};
child.start();
}实现原理参见 Thread 类的 init 方法：
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc) {
... ...
if (parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
... ...
}如果父线程的 inheritableThreadLocals 属性不为空，则将父线程的 inheritableThreadLocals 属性赋给子线程即可实现父子线程共享 threadlocal；