1.定义
ThreadLocal是线程变量，就是说每一个线程都有对应的该变量副本，线程修改该变量时，线程与线程之间的变量是相互隔离的，互相并看不见。这个结构附带在线程上，一个线程可以根据ThreadLocal对象查询到绑定到该线程上的值。
2.主要方法
ThreadLocal的主要方法都是基于ThreadLocal的静态内部类ThreadLocalMap进行操作的。
//map的初始大小为16，必须为2的幂次方
private static final int INITIAL_CAPACITY = 16; //Entry类型的tabel，扩容的时候必须是2的幂次方
private Entry[] table; //table中真实存储的Entry数目
private int size = 0; //阈值大小，当到达阈值大小，要进行扩容操作
private int threshold; // Default to 0
ThreadLocalMap的主要成员变量：
可以根据成员变量看出ThreadLocal的table大小始终是2的幂次方，当真实大小达到了阈值，要对table进行扩容。
而table就是主要存放ThreadLocal值的地方，Entry是个啥类型呢？
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
Entry类存放了key,value键值对，这里的key是对ThreadLocal的弱应用，value就是值。
ThreadLocalMap的主要方法
//根据key和value构造一个map，这时map的大小为16，map中只有一个Entry，size为1，阈值也为16
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);
} //根据key获取Entry
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);
} //将key和value添加到map中，如果说key存在，就覆盖value,如果说key是null，被回收，则进行替换老旧的entry，要不然就插入新的entry,并检查是否map大小溢出。 //如果说大小超过阈值，则将map进行扩容，并且重新进行rehash
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();
}
/**
* Double the capacity of the table.
*/
//扩容时是将容量变为原来的两倍
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
int count = 0; for (int j = 0; j < oldLen; ++j) {
Entry e = oldTab[j];
if (e != null) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null; // Help the GC
} else {
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
} setThreshold(newLen);
size = count;
table = newTab;
}
ThreadLocalMap总结：
1.每一个线程都有对应的ThreadLocalMap,在Thead类中有对map的引用
2.ThreadLocalMap的key值是ThreadLocal对象，值就是value值
3.每一个线程不仅仅只有一个ThreadLocal变量，所以map中存储了该线程所有的ThreadLocal变量
4.key值是对ThreadLocal的弱应用，如果这里使用普通的key-value形式来定义存储结构，实质上就会造成节点的生命周期与线程强绑定，只要线程没有销毁，那么节点在GC分析中一直处于可达状态，没办法被回收，而程序本身也无法判断是否可以清理节点。弱引用是Java中四档引用的第三档，比软引用更加弱一些，如果一个对象没有强引用链可达，那么一般活不过下一次GC。当某个ThreadLocal已经没有强引用可达，则随着它被垃圾回收，在ThreadLocalMap里对应的Entry的键值会失效，这为ThreadLocalMap本身的垃圾清理提供了便利。
其实，一直困扰在为啥ThreadLocal为每一个线程都有一个map,这么大的map就存一个ThreadLocal不是很浪费嘛，看源码对map还有扩容的机制，更是不理解，后来发现一个线程不仅仅只使用一个ThreadLocal变量，多个ThreadLocal其实是存放在一个map中。
ThreadLocal主要方法
ThreadLocal主要方法就是set(value)和get()，设置和获取变量的值。
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//根据当前线程获取内置的ThreadLocalMap对象，每一个线程都有对应的map
ThreadLocalMap map = getMap(t);
//如果map存在，直接向map中添加值
//如果map不存在，创建属于该线程的map
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
//为一个线程对象创建ThreadLocalMap对象
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
在看createMap这个函数的时候，发现将创建的ThreadLocalMap对象是赋值给了Thread的threadlocals，Thread类有成员变量ThreadLocalMap交给ThreadLocal进行维护。
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
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 getMap(Thread t) {
return t.threadLocals;
}
ThreadLocal的get()函数首先获取对应线程的threadLocalMap,再根据ThreadLocal的hash值获取map中的value值。
3.ThreadLocal导致的内存泄露
为啥ThreadLocalMap中的key要是弱应用？
如果是强引用的话，当线程的ThreadLocal对象被回收了。但是线程有一个成员变量threadlocals是对map的引用，map又对key有强引用，那么key就无法回收，就会每个线程的map越来越大。
但如果是弱引用，当ThreadLocal对象被回收，对key值就会只有一个弱引用，弱引用的对象只能存活到下一次GC的时候。所以key就会被GC,value在get,set和removed的时候也会被回收。
那为啥ThreadLocal依然内存泄露的危险？
value值会存在一条强引用链，当线程存活时，Thread->Thread.threadlocals->ThreadLocalMap->value。
所以只要线程结束了，那么对应的threadLocalMap一定会被回收，不存在内存泄露的风险。
但是要是使用的是线程池，线程存活时间长，那么线程的threadLocalMap也不会被回收，那么就一直会存在一条对value值的强引用，无法回收value，就会造成内存泄露。
在使用线程池和ThreadLocal时，如何避免内存泄露？
在每次使用完ThreadLocal时，便调用ThreadLocal的remove()方法，remove()方法会在map中删除整个entry。
在使用线程池的情况下，没有及时清理ThreadLocal，不仅是内存泄漏的问题，更严重的是可能导致业务逻辑出现问题。所以，使用ThreadLocal就跟加锁完要解锁一样，用完就清理。