JDK中有一个ThreadLocal类，使用很方便，但是却很容易出现问题。究其原因， 就是对ThreadLocal理解不到位。最近项目中，出现了内存泄漏的问题。其中就有同事在使用ThreadLocal时，没有用好。所以特写下此文。
ThreadLocal的设计
ThreadLocalMap、ThreadLocal说明
使用ThreadLocal后的内存模型
如何正确的使用ThreadLocal
错误的使用ThreadLocal会造成内存泄漏
ThreadLocal设计
ThreadLocal的类图：
·每个Thread都有一个自己的ThreadLocalMap，默认是null。当线程运行过程中，首次使用某个ThreadLocal对象时，会初始化这个ThreadLocalMap。
·ThreadLocalMap中包括一个Entry数组。我们在程序中是不能直接使用ThreadLocalMap的。在每次使用ThreadLocal时(set,get,remove)，都会自动的使用ThreadLocalMap，进行一定的清理工作。参见方法expungeStaleEntry。
·Entry继承了WeakReference，Key是ThreadLocal对象，Value时目标对象。并且key是被Weak Reference的。所以如果一个ThreadLocal对象TL1被GC后，也就是key是null。
·每个ThreadLocal对象都有一个initValue。在继承ThreadLocal类时，可以对它的initialValue()进行重写。ThreadLocal对外提供了3个常用方法：get,set,remove。
此外，当线程被kill(通过interrupe，或者线程自然结束)时，ThreadLocalMap会被设置为null,那么Map中的各个变量也会被回收（如果不被其它变量引用的话）。
ThreadLocalMap、ThreadLocal说明
ThreadLocalMap
ThreadLocalMap中的expungeStaleEntry(int)方法的可能被调用的处理有：
通过这个图，不难看出这个方法在ThreadLocal的set,get,remove时都会被调用。
从该方法代码中，可以看出是先清理指定的Entry，再遍历，如果发现有Entry的key是null，清理之。Key =null，也就是ThreadLocal对象是null。所以当程序中，将ThreadLocal对象设置为null,在该线程继续执行时，如果执行另一个ThreadLocal时，就会触发该方法。就有可能清理掉key是null的那个ThreadLocal对应的值。
ThreadLocal方法说明：
set() 将目标对象作为当前线程的局部变量的值设置。也就是说，变量名是ThreadLocal对象，变量值是目标对象。
get()，从当前对象中取出ThreadLocal变量的值。如果map中不并在该ThreadLocal变量，就会自动调用initialValue方法。并将该值设置到map中。
remove()，从当前线程中移除ThreadLocal变量的值。此时key,value都不存在map中。
使用ThreadLocal后的内存模型
假设程序中指定2个ThreadLocal的变量TL1、TL2，并且他们都是static时。
private static ThreadLocal<ClassB> TL1 = new ThreadLocal<ClassB>(); private static ThreadLocal<ClassA> TL2 = new ThreadLocal<ClassA>();
在运行时有2个线程，每个线程中都设置了这两个线程局部变量TL1,TL2。那么内存模型将是这样的：
在线程Thread1执行过程中，如果执行顺序是这样的：
TL1.set(ObjB1); //将TL1作为变量名，OBjB1作为变量值设置到Thread1中。 TL1.get(); //从当前线程Thread1中取出变量TL1的值。它的值应该是OBjB1 TL2.set(ObjA1); //将TL2作为变量名，OBjA1作为变量值设置到Thread1中。 TL2.get(); //从当前线程Thread1中取出变量TL1的值。它的值应该是OBjA1
当执行remove时，应会将该值从ThreadLocalMap中移出。
如何正确使用ThreadLocal呢?
在说如何正确使用之前，先来看一个例子：
package com.fjn.jdk.thread_concurrent.threadlocal;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.junit.Test;
public class ThreadLocalTest {
@Test
public void testUsingThreadPool() {
ExecutorService executor = Executors.newCachedThreadPool();
int workerThreadNumber =10;
CountDownLatch countDowner = new CountDownLatch(workerThreadNumber);
for (int i = 0; i < workerThreadNumber; i++) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// clear interrupted flag
Thread.interrupted();
}
executor.submit(new Task(countDowner));
}
try {
countDowner.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executor.shutdownNow();
}
}
class NamedThreadLocal<T> extends ThreadLocal<T> {
private String name;
public NamedThreadLocal(String name) {
this.name = name;
}
public String toString() {
return "The thread local [" + name + "] is " + this.get();
}
}
class BusService {
private CooperationService cooperateService = CooperationService.getService();
public void doService(String str) {
try {
cooperateService.recordStartTime();
Thread.sleep(500);
doSomething(str);
Thread.sleep(500);
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
} finally {
cooperateService.clear();
// 此时ThreadLocalMap中已不存在该变量。
}
// 正常情况下是不能要这一行代码的：
// 因为这样做又会重新在ThreadLocalMap中添加一个ThreadLocal变量，并设置值为initailValue
System.out.println(cooperateService.getStartTime());
}
private void doSomething(String str) {
System.out.println(" do something beging ...");
System.out.println("start time is : " + cooperateService.getStartTime());
System.out.println(str);
System.out.println(" do something end ...");
}
}
class CooperationService {
private static CooperationService ins = new CooperationService();
private static ThreadLocal<Long> threadLocal = new NamedThreadLocal<Long>("Test") {
protected Long initialValue() {
return -1l;
};
};
private CooperationService(){
}
public static CooperationService getService(){
return ins;
}
public void recordStartTime() {
long now = System.currentTimeMillis();
System.out.println("record start time : " + now);
threadLocal.set(now);
}
public Long getStartTime() {
return threadLocal.get();
}
public void clear() {
threadLocal.remove();
}
}
class Task implements Runnable {
private final CountDownLatch countDownLatch;
public Task(CountDownLatch countDowner) {
this.countDownLatch = countDowner;
}
@Override
public void run() {
BusService service = new BusService();
service.doService("hello");
if (countDownLatch != null) {
countDownLatch.countDown();
}
}
}
上面的例子中，使用线程池执行一个Task。Task的内容是调用相关的业务服务，在业务处理过程中，会先记录下业务处理的开始时间，处理过程中可能会使用到这个开始时间，譬如说要将开始处理时间记录到DataBase中。在用完之后，线程要完成任务之前，调用remove将该变量从线程中移出。
在调用ThreadLocal方法get,set,remove时，正确的姿势应该是：
TL1.set(obj);
Try{
// . . .
TL1.get();
// . . .
}
Finally{
TL1.remove();
}
那么ThreaLocal变量该如何声明呢？
要分为下面几个使用场景了：
1）如果ThreadLocal可以完全在一个方法中使用，不会到另一个方法中使用该ThreadLocal对象。对于这种情况：ThreadLocal完全可以作为该方法的局部变量。例如：
Class Hello {
public void hello () {
// . . .
ThreadLocal<Long> tl = new ThreadLocal<Long>();
tl.set(obj);
// . . .
tl.remove();
}
}
但这种情况毕竟是少数，因为在这种情况下，完全可以不用ThreadLocal的。
2）如果ThreadLocal是在同一个类中的不同方法中使用，可以将ThreadLocal作为该类的字段。
public class Hello {
[static] ThreadLocal<Long> tl = new ThreadLocal<Long>();
public void method1(){
// . . .
tl1.set();
// . . .
method2();
}
private void method2(){
tl.get();
// . . .
tl.remove();
}
}
这种情况用的相对来说，会多一些。在这种情况下，通常建议的做法是将ThreadLocal声明为static的，但也不是必须的。
3）ThreadLocal要跨类使用，一种方案是将ThreadLocal设置为public static的。另一种方案是像上面的例子一样。
错误使用ThreadLocal造成内存泄漏
实际使用过程中，大家很少会去使用ThreadLocal.remove()方法。另外，还有人会用ThreadLocal来做cache，那就更不可能去使用remove方法了。
前面提到，当线程结束时，ThreadLocalMap也会被自动清理，ThreadLocalMap中的对象如果没有其它的引用，就会被GC掉，这样就不会发生内存泄漏了。
如果线程A没有结束，某个ThreadLocalA对象如果被设置为null，线程A再次执行时，如果还使用到其它的ThreadLocalB。ThreadLocalA关联到的对象也会从ThreadLocalMap中移出。这样也可以避免内存泄漏。
如果线程A没有结束，某个ThreadLocalA对象如果被设置为null，线程A再次使用时，如果是执行的其它的任务，没有使用到任何的ThreadLocal，那么就会造成内存泄漏。
在使用ThreadLocal时，理解它很重要，更要知道怎么用它。
