大家都已经知道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()方法等,造成内存泄漏。