在一般的网站开发中，基于Java的Web 框架都使用了ThreadLocal来存储一些全局的参数，在拦截器\Filter中设置变量，让变量可以在任意地方被获取。
一早就了解到里面有用到WeakReference(弱引用)，但对弱引用仅限于一种懵懂的概念，并且认为只要GC，弱引用的对象就被回收掉了，实际情况呢？
Thread对象有一个变量名为 threadLocals 的 ThreadLocalMap对象，这个类和HashMap类似，里面定义了一个Entry数组，不过这个Entry对象弱引用了ThreadLocal
/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object). Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table. Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value; Entry(ThreadLocal k, Object v) {
super(k); //调用父类构造函数，设置Reference的referent属性
value = v;
}
}
/**
* Set the value associated with key.
*
* @param key the thread local object
* @param value the value to be set
*/
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(); 获取Reference的referent属性 if (k == key) {
e.value = value;
return;
} if (k == null) {
replaceStaleEntry(key, value, i); //清理掉陈旧Entry，这种Entry是由于ThreadLocal变量对象被回收后k==null造成的
return;
}
} tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
注意以下方法
if (k == null) {
replaceStaleEntry(key, value, i); //清理掉陈旧Entry，这种Entry是由于ThreadLocal变量对象被回收后k==null造成的
return;
}
这个地方其实也解释了通常所说的ThreadLocal变量可能导致内存溢出的问题：
Entry弱引用了ThreadLocal，因此Entry是否存活，不会影响ThreadLocal的生命周期，ThreadLocal在没有其他对象引用后被回收，但是它对应的Entry中的value实际还在被Entry引用，而这不是一个弱引用，如果不清掉掉Entry，value就被一直强引用，无法释放，那么就可能会内存溢出
如果一直没有ThreadLocal变量访问，并且线程一直存活，就不会清理陈旧Entry，value永远无法释放，这也是某种意义上的内存泄露
一直以来，我把WeakReference理解成：弱引用的对象一定会在下次GC时回收掉，按此推断，ThreadLocal变量是不太安全的，因为用着用着就可能被GC掉了。
但是如果ThreadLocal有这么严重的问题，谁会去用呢！
实际上对象B弱引用了A，如果A除了B以外，没有其他引用(强、软引用)时，才会把A GC调，这也是为什么ThreadLocal实际上是一个安全的操作。
Thread.threadLocals 是一个Map，每个Entry都弱引用了ThreadLocal对象
因此Thread.threadLocals对每个ThreadLocal对象都是弱引用关系
调用ThreadLocal.get()方法
/**
* Returns the value in the current thread's copy of this
* thread-local variable. If the variable has no value for the
* current thread, it is first initialized to the value returned
* by an invocation of the {@link #initialValue} method.
*
* @return the current thread's value of this thread-local
*/
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t); 可以看到get实际上是获取当前线程的ThreadLocalMap
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
} /**
* Get the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param t the current thread
* @return the map
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
可以理解为一个ThreadLocal实例，在多个线程都存在副本，并且在不同线程设置的值，都不会影响到其他线程，因为ThreadLocal实例是存储在当前Thread对象上的
也就是说，如果Thread死掉后，它和ThreadLocal对象也就没有任何关系了，这对我们的程序没有任何影响，因为我们也没有机会再取它在Thread中的副本了；
而ThreadLocal变量被设置为null后，虽然Thread中的Entry弱引用了ThreadLocal，即使Thread对象还在，当ThreadLocal对象没有被其他对象引用后，它就可以被GC调了，Thread对象产生了弱引用，不会影响到ThreadLocal变量的回收
其他知识点：
需要注意的是，当一个线程执行Thread.start()后，如果start()方法已经执行完毕了，虽然Thread对象还在，其实它的生命周期已经结束了，对应的ThreadLocal变量可以被回收
如果线程再次调用Thread.start()方法，会抛出异常，因此不用关注线程再次被启动，因为它已经无法再被启动了（PS：线程复用技术并非是重新start，而是在线程内执行多个任务）
以下情况ThreadLocal变量是永远不会回收的
public class FlagContext {
/**
* ThreadLocal变量
*/
private final static ThreadLocal<Boolean> tbFlag = new ThreadLocal<Boolean>();
}
FlagContext的静态变量引用了ThreadLocal实例tbFlag，tbFlag是个final 声明的变量，永远不会为空，因此，这种情况下，tbFlag对应的值，只会在线程生命周期结束，或调用tbFlag.remove()才会被回收！原因呢：
ThreadLocal永远被FlagContext强引用了，而Thread和ThreadLocal不管是否是弱引用，即使Thread中的Entry被回收了，也不会被GC掉！