ThreadLocal是什么、有什么、能做什么？
ThreadLocal提供一个线程（Thread）局部变量，访问到某个变量的每一个线程都拥有自己的局部变量。说白了，ThreadLocal就是想在多线程环境下去保证成员变量的安全。
ThreadLocal提供的方法
对于ThreadLocal而言，常用的方法，就是get/set/initialValue方法。
我们先来看一个例子
运行结果
很显然，在这里，并没有通过ThreadLocal达到线程隔离的机制，可是ThreadLocal不是保证线程安全的么？这是什么鬼？
虽然，ThreadLocal让访问某个变量的线程都拥有自己的局部变量，但是如果这个局部变量都指向同一个对象呢？这个时候ThreadLocal就失效了。仔细观察下图中的代码，你会发现，threadLocal在初始化时返回的都是同一个对象a！
再看个例子：
public class TestThreadLocal {
public static Integer num = 10;
public static Integer num2 = 11;
public static String num3 = "哈哈哈";
public static final ThreadLocal threadLocal = new ThreadLocal();
public static final ThreadLocal threadLocal1 = new ThreadLocal();
public static void main(String[] args) {
Thread[] threads = new Thread[5];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
threadLocal.set(num );
threadLocal.set(num2);
threadLocal1.set(num3);
System.out.println(Thread.currentThread().getName()+":"+threadLocal.get()+"---"+threadLocal1.get());
}
}, "Thread-" + i);
}
for (Thread t:threads) {
t.start();
}
}
}输出：
Thread-0:11---哈哈哈
Thread-1:11---哈哈哈
Thread-2:11---哈哈哈
Thread-3:11---哈哈哈
Thread-4:11---哈哈哈ThreadLocal源码
##set操作：
/**
* Sets the current thread's copy of this thread-local variable
* to the specified value. Most subclasses will have no need to
* override this method, relying solely on the {@link #initialValue}
* method to set the values of thread-locals.
*
* @param value the value to be stored in the current thread's copy of
* this thread-local.
*/
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
//在ThreadLocalMap中设置key为threadlocal对象，value为自己设置的值的键值对
map.set(this, value);
else
createMap(t, value);
} /**
* 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;//线程的局部变量
}
/**
* Create the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param t the current thread
* @param firstValue value for the initial entry of the map
*/
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}你会看到，set需要首先获得当前线程对象Thread；
然后取出当前线程对象的成员变量ThreadLocalMap；
如果ThreadLocalMap存在，那么进行KEY/VALUE设置，KEY就是ThreadLocal；
如果ThreadLocalMap没有，那么创建一个；
说白了，当前线程中存在一个Map变量，KEY是ThreadLocal，VALUE是你设置的值。
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);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}这里其实揭示了ThreadLocalMap里面的数据存储结构，从上面的代码来看，ThreadLocalMap中存放的就是Entry，Entry的KEY就是ThreadLocal，VALUE就是值。
ThreadLocalMap.Entry：
/**
* 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);
value = v;
}
}可以看到Entry继承了弱应用。
在JAVA里面，存在强引用、弱引用、软引用、虚引用。这里主要谈一下强引用和弱引用。
强引用，就不必说了，类似于：
A a = new A();
B b = new B();
考虑这样的情况：
C c = new C(b);
b = null;
考虑下GC的情况。要知道b被置为null，那么是否意味着一段时间后GC工作可以回收b所分配的内存空间呢？答案是否定的，因为即便b被置为null，但是c仍然持有对b的引用，而且还是强引用，所以GC不会回收b原先所分配的空间！既不能回收利用，又不能使用，这就造成了内存泄露。
那么如何处理呢？
可以c = null;也可以使用弱引用！（WeakReference w = new WeakReference(b);）
分析到这里，我们可以得到：
假设方法执行完毕，栈中的ThreadLocal ref出栈，如果Entry中的ThreadLocal的变量对堆中ThreadLocal是强引用的话，GC不会收集使用完毕的ThreadLocal类，这就造成了内存泄漏。但是如果采用的是弱引用，当ref使用完毕，不存在指向ThreadLocal类的引用，这时GC在下次收集时就会收集使用完毕的ThreadLocal类。
这里我们思考一个问题：ThreadLocal使用到了弱引用，是否意味着不会存在内存泄露呢？
首先来说，如果把ThreadLocal置为null，那么意味着Heap中的ThreadLocal实例不在有强引用指向，只有弱引用存在，因此GC是可以回收这部分空间的，也就是key是可以回收的。但是value却存在一条从Current Thread过来的强引用链。因此只有当Current Thread销毁时，value才能得到释放。
因此，只要这个线程对象被gc回收，就不会出现内存泄露，但在threadLocal设为null和线程结束这段时间内不会被回收的，就发生了我们认为的内存泄露。最要命的是线程对象不被回收的情况，比如使用线程池的时候，线程结束是不会销毁的，再次使用的，就可能出现内存泄露。
那么如何有效的避免呢？
事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话，那么是会对value置为null的。我们也可以通过调用ThreadLocal的remove方法进行释放！
