ThreadLocal用来存储线程隔离的数据。
Thread类中有一个ThreadLocalMap成员变量threadLocals,ThreadLocalMap中有一个ThreadLocal.ThreadLocalMap.Entry[16]数组table,用来存储该线程的ThreadLocal的存储的值。多个ThreadLocal在设置时通过ThreadLocal的成员变量threadLocalHashCode和数组大小-1与操作，得到存储的下标值。
ThreadLocal的常规用法：
ThreadLocal<String> stringThreadLocal = new ThreadLocal<>(){
@Override
// 设置初始值
protected String initialValue() {
return "stringThreadLocal initialValue";
}
};
ThreadLocal<Integer> intThreadLocal = new ThreadLocal<>(){
@Override
protected Integer initialValue() {
return 1;
}
};
Thread t = new Thread(new Runnable() {
@Override
public void run() {
stringThreadLocal.get();
stringThreadLocal.set("set new value");
// 使用完后最好进行移除，防止内存泄漏
stringThreadLocal.remove();
}
});
一个线程可以拥有多个ThreadLocal，用来存储多个不同的值，可以使用initialValue()方法进行初始化值。
ThreadLocal是如何保证线程隔离，存储数据的？
ThreaLocal类中有一个静态内部类ThreadLocal.ThreadLocalMap,而ThreadLocalMap中有一个静态内部类ThreadLocal.ThreadLocalMap.Entry，Entry中的成员变量Object value 用来存储ThreadLocal设置的值。
ThreadLocal的get方法
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
// 当前线程作为key值，获取ThreadLocalMap
ThreadLocal.ThreadLocalMap map = this.getMap(t);
if (map != null) {
// 通过getEntry方法传入当前的ThreadLocal变量，经过运算获取Entry的值
ThreadLocal.ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
T result = e.value;
return result;
}
}
// 返回设置的初始值
return this.setInitialValue();
}
ThreadLocal.ThreadLocalMap getMap(Thread t) {
// 通过传入当前线程，获取线程的成员变量threadLocals
return t.threadLocals;
}
// ThreadLocalMap中的getEntry方法
private ThreadLocal.ThreadLocalMap.Entry getEntry(ThreadLocal<?> key) {
// 计算Entry存储的下标
int i = key.threadLocalHashCode & this.table.length - 1;
// 通过ThreadLocal.ThreadLocalMap.Entry[] table 数组获取对应的Entry
ThreadLocal.ThreadLocalMap.Entry e = this.table[i];
return e != null && e.get() == key ? e : this.getEntryAfterMiss(key, i, e);
}
可用看到，通过Thread.currentThread()获取当前线程，通过当前线程作为键值，获取到ThreadLocalMap。而这个ThreadLocalMap就是线程中的成员变量threadLocals，这就与Thread对应起来了。再通过获取到的ThreadLocalMap通过getEntry()方法，传入当前的ThreadLocal获取ThreadLocal存储的值。
ThreadLocal的set()方法
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocal.ThreadLocalMap map = this.getMap(t);
if (map != null) {
map.set(this, value);
} else {
this.createMap(t, value);
}
}
// ThreadLocalMap中的set方法
private void set(ThreadLocal<?> key, Object value) {
// 数组，用来存储对应的Entry
ThreadLocal.ThreadLocalMap.Entry[] tab = this.table;
int len = tab.length;
// 通过threadLocalHashCode加上与操作，获取下标
int i = key.threadLocalHashCode & len - 1;
// 获取对应的ThreadLocal进行值的设置
for(ThreadLocal.ThreadLocalMap.Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = (ThreadLocal)e.get();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
this.replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value);
int sz = ++this.size;
if (!this.cleanSomeSlots(i, sz) && sz >= this.threshold) {
this.rehash();
}
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);
}
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
this.table = new ThreadLocal.ThreadLocalMap.Entry[16];
int i = firstKey.threadLocalHashCode & 15;
this.table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
this.size = 1;
this.setThreshold(16);
}
可以看到，ThreadLocalMap中通过table来保存一个大小为16的ThreadLocal.ThreadLocalMap.Entry数组，而这个数组就是用来存储ThreadLocal.ThreadLocalMap.Entry的，也就是说多个ThreadLocal设置的值，通过这个数组来进行保存。
ThreadLocal的线程不安全
ThreadLocal在设置一个同一个对象的值时，可能存在线程不安全的问题。因为ThreadLocal存储的是栈中一个对象的引用，而对象是存储在堆中的，ThreadLocal对这个对象的引用指向的其实是堆中的同一个对象。所以一个线程对这个对象的值进行更改时，其它ThreadLocal在取值时也会被修改。
解决方法：1. 不要存储同一个对象。2. 使用initialValue()对每个TreadLocal进行赋值初始值。
Integer的valueOf方法：
public static Integer valueOf(int i) {
return i >= -128 && i <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[i + 128] : new Integer(i);
}
在这可以看到，如果对Integer的值进行加减操作，并且存储的值不是在-128~127之间的时候，会创建一个新的Integer对象。
ThreadLocal导致内存泄漏
使用ThreadLocal进行存取值时，传入的ThreadLocal作为键值时用弱引用包裹的，当发生GC时，如果ThreadLocal被GC回收掉了，那么这个key值就不存在了，而Thread中存储的ThreadLocal.ThreadLocalMap 是一个强引用，不会被GC回收，这种情况下，就会发生内存泄漏。只有当前thread结束以后, current thread就不会存在栈中,强引用断开, Current Thread, Map, value将全部被GC回收。
所以当ThreadLocal使用完成的时候，需要调用remove方法将value移除掉，这样就不会存在内存泄漏了。
key值为什么使用弱引用而不是强引用？
下面我们分两种情况讨论：
key 使用强引用：对 ThreadLocal 对象实例的引用被置为 null 了，但是 ThreadLocalMap 还持有这个 ThreadLocal 对象实例的强引用，如果没有手动删除， ThreadLocal 的对象实例不会被回收，导致 Entry 内存泄漏。
key 使用弱引用：对 ThreadLocal 对象实例的引用被被置为 null 了，由于 ThreadLocalMap 持有 ThreadLocal 的弱引用，即使没有手动删除，ThreadLocal 的对象实例也会被回收。value 在下一次 ThreadLocalMap 调用 set，get，remove 都 有机会被回收。
比较两种情况，我们可以发现：由于 ThreadLocalMap 的生命周期跟 Thread 一样长，如果都没有手动删除对应 key，都会导致内存泄漏，但是使用弱引用可 以多一层保障。
因此，ThreadLocal 内存泄漏的根源是：由于 ThreadLocalMap 的生命周期跟Thread 一样长，如果没有手动删除对应 key 就会导致内存泄漏，而不是因为弱引用。
