正文
之前在项目中与看到过ThreadLocal出现，但是一直不明白什么意思。而且最近也在从新学习多线程。正好有学到ThreadLocal。在次做一个记录。
ThreadLocal是什么意思？
ThreadLocal的实例代表了一个线程局部的变量，每条线程都只能看到自己的值，并不会意识到其它的线程中也存在该变量。它采用采用空间来换取时间的方式，解决多线程中相同变量的访问冲突问题。
先来看一段代码
class Data { public Integer count = 0; public Integer getNumber() { return ++count; } } public class ThreadLocalDemo extends Thread { private Data data; public ThreadLocalDemo(Data data) { this.data = data; } @Override public void run() { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName() + "," + data.getNumber()); } } public static void main(String[] args) { Data data= new Data(); ThreadLocalDemo t1 = new ThreadLocalDemo(data); ThreadLocalDemo t2 = new ThreadLocalDemo(data); t1.start(); t2.start(); } }
通过这个图可以看到两个线程操作了一个变量，这样在实际情况下是不行的。一个线程在改变变量的时候另外一个线程也在改变这个变量。这样就会出现多线程中相同变量的访问冲突问题。
我们可以通过创建两个实例对象来给变这样
、
这种情况解决了相同变量的访问冲突问题。但是我们还可以使用ThreadLocal来解决这个问题。ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
ThreadLocal的四个方法：
void set(Object value)设置当前线程的线程局部变量的值。
public Object get()该方法返回当前线程所对应的线程局部变量。
public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
protected Object initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。
使用ThreadLocal来改变刚刚的代码
class Data { public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() { protected Integer initialValue() { return 0; }; }; public Integer getNumber() { int count = threadLocal.get() + 1; threadLocal.set(count); return count; } } public class ThreadLocalDemo extends Thread { private Data data; public ThreadLocalDemo(Data data) { this.data = data; } @Override public void run() { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName() + "," + data.getNumber()); } } public static void main(String[] args) { Data res = new Data(); ThreadLocalDemo t1 = new ThreadLocalDemo(res); ThreadLocalDemo t2 = new ThreadLocalDemo(res); t1.start(); t2.start(); } }
这样就可以解决变量冲突。但是我没有搞懂ThreadLocal 与 给每个线程实例传递一个新的变量，这两种做法的区别。如果有小伙伴知道的话可以帮忙告知一下。
ThreadLocal内存溢出的问题和如何避免
ThreadLocal的原理：Thread内部维护ThreadLocalMap，它其实是一个Map,这个map的Key是一个弱引用也就是ThreadLocal的本身，Value才是真正存储的线程变量Object.而弱引用的生命周期只能存活到下次GC之前
内存泄漏的原因：因为ThreadLocalMap中是以一个弱引用身份被Entry中的Key引用的，所以当ThreadLocal没有外部强引用来引用的话，那在下次Gc的时候就会被回收。这个时候Key已经被回收了，出现了null Key。也无法根据Null Key 找到Value。如果当前线程生命周期很长的话就会出现一条强引用链：Thread --> ThreadLocalMap-->Entry-->Value，这条强引用链会导致Entry不会回收，Value也不会回收，但Entry中的Key却已经被回收的情况，造成内存泄漏。JVM团队也考虑到了这样的情况，所以每次在ThreadLocal的get()、set()、remove()方法调用的时候会清除掉线程，这样ThreadLocalMap中所有Entry中Key为null的Value，并将整个Entry设置为null，利于下次内存回收。这样就尽量避免了内存泄漏。
static class Entry extends WeakReference<ThreadLocal<?>> { Object value; //ThreadLocal为key,真正需要存储的对象为value Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }
可以看下具体的源码
1、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); }
ThreadLocal在调用set方法时，如果 getMap返回的为null，那么表示该线程的 ThreadLocalMap 还没有初始化，所以调用createMap进行初始化：t.threadLocals = new ThreadLocalMap(this, firstValue);
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); }
初始化16的数组，并将firstKey、firstValue存入map。
如果getMap没有返回NULL
private void set(ThreadLocal<?> key, Object value) { Entry[] tab = table; int len = tab.length; //定位hash桶的位置 int i = key.threadLocalHashCode & (len-1); //发生hash碰撞时如果碰撞的位置上已经有Entry，且原有的key没有被回收，就查找数组下一个位 for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { ThreadLocal<?> k = e.get(); //Key存在就替换原来的value值 if (k == key) { e.value = value; return; } //key为空就替换并清除过期的Entry if (k == null) { replaceStaleEntry(key, value, i); return; } } //在空的位置上放入Entry之前先判断是否需要扩容 tab[i] = new Entry(key, value); int sz = ++size; if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); }
2、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(); }
同样需要根据map是否为空来进行出来，如果没有初始化ThreadLocalMap就会返回setInitialValue（）
/** * setInitialValue方法很简单，定义一个value指向null，如果ThreadLocalMap 不为空，就插入value；如果ThreadLocalMap为空，先调用createMap初始化ThreadLoaclMap，再插入value。最后返回的就是value。 */ private T setInitialValue() { T value = initialValue(); Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); return value; }
调用getEntry（）
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); }
先定位hash桶的位置，然后根据桶位置找到Entry,如果Entry不为null且相同就返回对应的值。如果不符合调用getEntryAfterMiss（）在进行处理
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { Entry[] tab = table; int len = tab.length; //从当前位置向下寻找 while (e != null) { ThreadLocal<?> k = e.get(); //相同就直接返回结果 if (k == key) return e; //如果为null调用expungeStaleEntry()处理 if (k == null) expungeStaleEntry(i); //继续寻找下一个位置 else i = nextIndex(i, len); e = tab[i]; } //最后没找到返回NULL return null; }
expungeStaleEntry（）其实就是将Entry删除。防止内存泄漏。但是这样并不能完全保证内存不发生泄漏，如果使用了static的ThreadLocal，延长了生命周期也是有可能导致内存泄漏的。
3、remove（）
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; } } }
也是找到hash桶的位置在遍历找到key然后找到相应的Entry并清理。最后也是调用了expungeStaleEntry（）
但是有个问题，为什么key要使用弱引用那？
表面上看导致内存泄漏是因为key使用了弱引用，使Entry的key为null之后没有主动清理value导致的。
其实可以分成两种情况讨论一下
key 使用强引用：引用的ThreadLocal的对象被回收了，但是ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄漏。
key 使用弱引用：引用的ThreadLocal的对象被回收了，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value在下一次ThreadLocalMap调用set,get，remove的时候会被清除。
比较两种情况，我们可以发现：由于ThreadLocalMap的生命周期跟Thread一样长，如果都没有手动删除对应key，都会导致内存泄漏，但是使用弱引用可以多一层保障：弱引用ThreadLocal不会内存泄漏，对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除。
因此，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key的value就会导致内存泄漏，而不是因为弱引用。
所以综上所述，每次用完ThreadLocal，都调用remove（）,清除数据。
参考博客连接 ：https://www.jianshu.com/p/a1cd61fa22da https://blog.csdn.net/liu1pan2min3/article/details/80236105