大家都已经知道threadlocal的值可以是线程私有，以保障多线程时能取到自己线程中的数据，类似文章很多，所以这里不再讲述threadlocal的作用，本篇文章除了讲源码外还有一个初学者比较容易忽略的地方
友情提示：文章篇幅较长，右边侧边栏有目录选项
使用
public class Test {
private static ThreadLocal<String> stringThreadLocal = new ThreadLocal<>();
private static ThreadLocal<Integer> integerThreadLocal = new ThreadLocal<>();
public static void main(String[] args) {
stringThreadLocal.set("abc");
integerThreadLocal.set(123);
System.out.println(stringThreadLocal.get());
System.out.println(integerThreadLocal.get());
}
}
没错，上述代码中就是一个初学者比较容易忽略的地方，当时我也比较疑惑的是一个线程中能不能有多个threadlocal呢，而且threadlocal的类型有什么要求呢，正确答案是可以有多个，而且类型也可以有多种，就像上边代码中所示。
源码解读（也要注意看注释）
先看一下原理图，也可以看完源码再拐回来想一下
ThreadLocal set()方法
既然先用到了threadlocal的set方法，那就先把threadlocal类中的set方法看一下，此方法是需要用到时手动设置threadlocal的值
public void set(T value) {
Thread t = Thread.currentThread(); //获取当前线程
ThreadLocalMap map = getMap(t); //获取当前线程的threadlocalmap
if (map != null)
map.set(this, value); //map不为空，直接放值，没错，这个map的key就是当前的threadlocal实例对象，value便是你的值
else
createMap(t, value); 当前线程的threadlocalmap为空，则调用创建方法
}
上边代码就是set源码了，我们一步步走，首先看*getMap()*方法
ThreadLocalMap getMap(Thread t) {
return t.threadLocals; //可以看到这个方法就是直接把当前线程的threadlocals变量拿过来
}
我们看线程中的threadlocals变量是怎么定义的（注意下边这个代码是Thread类中的，其它列的都是ThreadLocal中的源代码，别迷糊了）：
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
我们看到这个threadlcoals变量的类型就i是threadlocal中的threadLocalMap内部类，这个内部类我们直接看上边第一个源代码块中的map.set()方法：
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
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();
}
可以看到是一个entry数组。而entry是一个key，value，所以ThreadLocalMap可以理解为和hashmap类似，上边代码中的value是object，这个set方法可以理解为hashmap的put()方法,只不过这里的key为threadlocal实例对象，value为值，所以一个线程有一个map，而map中可以存放不同的类型值，key就是你代码中定义的threadlocal实例对象，可能此时你迷惑了，既然threadlocal是全局变量，那所有线程的实例对象不都是同一个吗，也就是key是一样的，对的，是这样的，因为每个线程都有自己的threadlocalmap作为自己的属性，这些map线程私有，所以这并不冲突，而这个map中可以存放不同的threadlocal实例作为key，也就是上边test代码中定义了多个threadlocal变量，他们放的类型可以是object任意子类，初学者们好好想一下便能理解。
当然如果认真看的话，走到这里已经了解的差不多了，接下来顺便把第一个源代码块中的最后一个createMap方法列一下吧：
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
直接创建一个map，key为threadlocal实例，value为值，赋给当前线程的threadlocalmap变量。
ThreadLocal get()方法
get方法很简单，就是获取值，这里都写在注释里了
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) { //如果我们这个线程调用过set方法后，这个map就不会为空，执行if里边内容，根据这个ThreadLocal的实例对象获取这个线程对应的值，其实这个步骤在setInitialValue方法中已经有了，这里的作用主要就是提前做一次判断，如果有值，就不再调用setInitialValue方法，提高效率
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();//如果我们没有执行过set()方法，那么就调用这个方法，下边再进行介绍
}
ThreadLocal setInitialValue()方法
贴出源码：这个方法是私有的，说明是内部使用的
private T setInitialValue() {
T value = initialValue(); //这里又调用了initialValue()方法，返回了一个值，下个方法介绍我们就看它，或者此处也可以直接跳过去看
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) //又一次进行了判断，检查这个过程中是否已经插入过值，如果有，则进行覆盖
map.set(this, value);
else
createMap(t, value); //如果没有值，那么将初始化方法中的值放进来
return value;
}
ThreadLocal initialValue()方法
可能这个方法容易忽略，在讲这个方法前，先穿插以下它的使用，下边是一个小示例：
/**
* 利用 ThreadLocal 给每个线程分配自己的 dateFormat 对象
* 不但保证了线程安全，还高效的利用了内存
*/
public class ThreadLocalNormalUsage05 {
public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 1000; i++) {
int finalI = i;
//提交任务
threadPool.submit(new Runnable() {
@Override
public void run() {
String date = new ThreadLocalNormalUsage05().date(finalI);
System.out.println(date);
}
});
}
threadPool.shutdown();
}
public String date(int seconds) {
//参数的单位是毫秒，从1970.1.1 00:00:00 GMT 开始计时
Date date = new Date(1000 * seconds);
//获取 SimpleDateFormat 对象
SimpleDateFormat dateFormat = ThreadSafeFormatter.dateFormatThreadLocal.get();
return dateFormat.format(date);
}
}
class ThreadSafeFormatter {
public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = new
ThreadLocal<SimpleDateFormat>(){
//创建一份 SimpleDateFormat 对象
@Override
protected SimpleDateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
}
};
}
可以看出我们在声明ThreadLocal时就创建了一个继承于ThreeadLocal的匿名类，并重写了initialValue方法，贴出上边运行结果：
initialValue()方法：
就是示例中我们初始化需要重写的方法，如果没有初始化就为空，从get方法中调用setInitialValue方法，setInitialValue调用initialValue方法我们可以知道，这个初始化方法只有调用get时才会执行这个方法（前提是该线程没有设置过值），然后将这个初始化值放到当前线程的threadLocals中，此时这个值才真正属于当前线程
protected T initialValue() {
return null;
}
ThreadLocal remove()方法
调用remove()方法，就会删除对应的Entry对象，可以避免内存泄漏，所以确定后边执行不会再用到对应的ThreadLocal的话，要调用remove()方法进行释放。
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
应用场景
1.每个线程需要一个独享对象（通常是工具类，典型需要使用的类有SimpleDateFormat和Random）
每个Thread内有自己的实例副本，不共享
比喻：教材只有一本，一起做笔记有线程安全问题。复印后没有问题，使用ThradLocal相当于复印了教材。
2.每个线程内需要保存全局变量（例如在拦截器中获取用户信息），可以让不同方法直接使用，避免参数传递的麻烦
注意事项
1.内存泄漏
问题
内存泄露；某个对象不会再被使用，但是该对象的内存却无法被收回
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
//调用父类，父类是一个弱引用
super(k);
//强引用
value = v;
}
}
强引用：当内存不足时触发GC，宁愿抛出OOM也不会回收强引用的内存
弱引用：触发GC后便会回收弱引用的内存
正常情况：
当Thread运行结束后，ThreadLocal中的value会被回收，因为没有任何强引用了
非正常情况：
当Thread一直在运行始终不结束，强引用就不会被回收，存在以下调用链 Thread–>ThreadLocalMap–>Entry(key为null)–>value因为调用链中的 value 和 Thread 存在强引用，所以value无法被回收，就有可能出现OOM。
JDK的设计已经考虑到了这个问题，所以在set()、remove()、resize()方法中会扫描到key为null的Entry，并且把对应的value设置为null，这样value对象就可以被回收。
但是只有在调用set()、remove()、resize()这些方法时才会进行这些操作，如果没有调用这些方法并且线程不停止，那么调用链就会一直存在，所以可能会发生内存泄漏。
注意：这里说的这几个方法是内部类ThreadLocalMap中的
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();
//当ThreadLocal为空时，将ThreadLocal对应的value也设置为null
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;
}
如何避免内存泄漏（阿里规约）
调用remove()方法，就会删除对应的Entry对象，可以避免内存泄漏，所以使用完ThreadLocal后，要调用remove()方法。
2.ThreadLocal的空指针异常问题
问题
/**
* ThreadLocal的空指针异常问题
*/
public class ThreadLocalNPE {
ThreadLocal<Long> longThreadLocal = new ThreadLocal<>();
public void set() {
longThreadLocal.set(Thread.currentThread().getId());
}
public Long get() {
return longThreadLocal.get();
}
public static void main(String[] args) {
ThreadLocalNPE threadLocalNPE = new ThreadLocalNPE();
//如果get方法返回值为基本类型，则会报空指针异常，如果是包装类型就不会出错
System.out.println(threadLocalNPE.get());
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
threadLocalNPE.set();
System.out.println(threadLocalNPE.get());
}
});
thread1.start();
}
}
解决方法
如果get方法返回值为基本类型，则会报空指针异常，如果是包装类型就不会出错。这是因为基本类型和包装类型存在装箱和拆箱的关系，造成空指针问题的原因在于使用者。
3.共享对象问题
如果在每个线程中ThreadLocal.set()进去的东西本来就是多个线程共享的同一对象，比如static对象，那么多个线程调用ThreadLocal.get()获取的内容还是同一个对象，还是会发生线程安全问题。
4.可以不使用ThreadLocal就不要强行使用
如果在任务数很少的时候，在局部方法中创建对象就可以解决问题，这样就不需要使用ThreadLocal。
5.优先使用框架的支持，而不是自己创造
例如在Spring框架中，如果可以使用RequestContextHolder，那么就不需要自己维护ThreadLocal，因为自己可能会忘记调用remove()方法等，造成内存泄漏。
