正文
之前在项目中与看到过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（）,清除数据。