话不多说，直接进入主题。
本文使用的是 jdk1.8
首先，先要了解ThreadLocal有什么用？
ThreadLocal是为了每个线程都有自己独立的变量或者对象。
那这时应该会有些疑问，为什么会有独立的变量？如果有的话，它的变量保存在哪？变量是如何从共享变量中复制出来的？
首先 Threadlocal 主要有 set() , get() , remove() , initialValue()，这几个方法，
- 我们先看看initialValue
**@return the initial value for this thread-local
protected T initialValue() {
return null;
}
jdk注释的意思就是 返回一个本地线程的初始值，至于为什么返回null，很明显这是个需要被重写的方法。
- 接着看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();
}
代码解析：
1、获取当前的线程
2、通过当前的线程返回一个ThreadLocalMap对象
3、如果ThreadLocalMap存在，就从中取得 它的Entry对象
4、从Entry对象中获取value
从现在的角度来看，这个value肯定就是 复制的变量，也就是副本变量。
- 先不说value，看看ThreadLocalMap是个什么东西？
看ThreadLocalMap为null的情况下调用的setInitialValue
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread(); **获取当前线程
ThreadLocalMap map = getMap(t); **通过当前线程获取map对象
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
代码解析：
1、从initialValue方法中去拿值，而我们知道这个方法返回的是null，也就是说如果不重写这个方法的话，只能通过set设值。
- 接着再看看createMap做了什么
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
创建了一个ThreadLocalMap对象，返回了一个线程的变量threadLocals。
这个createMap是ThreadLocal对象调用的，那这个t，是不是就是说ThreadLocal当前所在的线程。
- 我们看下ThreadLocalMap是什么东西？ 摘出核心代码
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;
}
}
}
······
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);
}
代码解析：
1、可以看到ThreadLocalMap内部是一个Entry对象，还是 key : value的键值对形式，说明ThreadLocalMap 并不是一个实现了map接口的对象，只是模仿hashmap键值对的形式， 不是一个map。
2、它用的是当前线程的ThreadLocal 作为key，value就是那个副本变量。并且Entry还继承的弱引用，这块是引起内存泄漏的点。后面说
也就是说 ThreadLocalMap保存的是 当前的ThreadLocal对象和当前线程要操作的副本变量。
- 接着我们返回get()方法
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
这里的get方法，是通过当前的线程获取一个ThreadLocalMap对象。我们看看getMap做了什么。
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
这个threadLocals是Thread里的一个成员变量。
public class Thread implements Runnable {
···
ThreadLocal.ThreadLocalMap threadLocals = null;
···
}
我们遇到了Thread 、 ThreadLocal 、ThreadLocalMap；
Thread的成员变量是threadLocals，ThreadLocal的get(thread) 方法找到的是ThreadLocalMap对象！
之前最开始的疑问？
1、为什么会有独立的变量？
因为ThreadLocalMap存在ThreadLocal这个类用，调用的get()或set()方法的时候，如果没有这个ThreadLocalMap，它就会自己创建。如果有的话，它会拿当前的线程对象作为key ，这个key都是不唯一的，所以每个线程能有自己独立的副本变量。
2、它的副本变量保存在哪？
ThreadLocalMap就是用来保存线程的副本 变量的，构造方法的时候，传入的第一个参数k 是当前所在的线程，另外参数v 就是副本变量。
3、副本变量是如何从共享变量中复制出来的？
重写initialValue()方法，或 调用set()的时候创建的。
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
get()的流程已经详细介绍过了，参考比对后清楚set()方法流程，不多介绍了。
到此set()、get()、initialValue()就都介绍了，还差一个remove();
接着往下看，
我们都知道GC在回收垃圾的时候，只有强引用关系存在的对象才不会被回收。
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;
}
}
}
而ThreadLocalMap中的Entry对象是继承了WeakReference（弱引用）提供的key。也就是说ThreadLocal取的是WeakReference提供的弱引用对象，所以在GC回收的时候ThreadLocal会被回收，Entry的key会为null，而value却是强引用，导致GC没办法回收。
为什么说value是强引用？
认真回顾一下，
value是自己的Object对象，然后ThreadLocalMap又是Thread的成员变量，而ThreadLocal又是ThreadLocalMap通过弱引用 引入的一个对象，取的是ThreadLocal的 弱引用 对象。所以GC的时候key肯定会回收了。然后如果这个方法运行时特别长，就产生了一条引用链导致value无法被回收。
currentThread->Thread->ThreadLocalMap->Entry->value
当然JDK肯定考虑到这个问题了，所以在加了remove()方法，还在get()方法中做了优化，get()->getEntry->getEntryAfterMiss()->expungeStaleEntry，意思就是说如果在调用get()方法的时候，key ==null 就也把value == null，但这样并不能完全的规避内存泄漏，也需要我们在调用set()方法后 remove();
public void remove() {
**1
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
/**
* Remove the entry for key.
*/
**2
private void remove(ThreadLocal<?> key) {
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)]) {
if (e.get() == key) {
e.clear();
expungeStaleEntry(i);
return;
}
}
}
**3
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
总结
1、ThreadLocalMap是Thread中的一个成员变量。ThreadLocal是被ThreadLocalMap引入的弱引用对象，value则是自己的object对象。
2、ThreadLocalMap是ThreadLocal的内部静态类，操作都由ThreadLocalMap做，ThreadLocal只是提供一系列操作方法。
3、ThreadLocalMap并不是一个map，是内部Entry模拟了K : V形式。
4、了解了内存泄漏产生的原因。get()时已经对内存泄漏做了处理key==null则value==null，但还需要自己配合调用remove()。
