深入剖析 ThreadLocal 原理

用户头像
JFound
关注
发布于: 2020 年 05 月 20 日
深入剖析ThreadLocal原理

描述

ThreadLocal,很多地方叫做线程本地变量,也有些地方叫做线程本地存储。ThreadLocal为变量在每个线程中都创建了一个副本,那么每个线程可以访问自己内部的副本变量。

通常使用静态的变量来维护ThreadLocal 如:

static ThreadLocal<String> userIdThreadLocal = new ThreadLocal<String>

通常用来保存userId、TransactionId等。

spring也很经常用ThreadLocal来保存一些内容。 如用org.springframework.web.context.request.RequestContextHolder来保存一些请求信息,方便整个线程调用。

ThreadLocal类提供的几个方法:

public T get() { }
public void set(T value) { }
public void remove() { }
protected T initialValue() { }

get() 方法是用来获取ThreadLocal在当前线程中保存的变量副本,set() 用来设置当前线程中变量的副本,remove() 用来移除当前线程中变量的副本,initialValue()是一个protected方法,一般是用来在使用时进行重写的,它是一个延迟加载方法,只有调用get() 方法的时候才有可能调用

demo
import java.util.concurrent.TimeUnit;
ublic class ThreadLocalDemo {
static ThreadLocal<String> local = new ThreadLocal<>();
public static void main(String[] args) throws InterruptedException {
local.set("main");
new Thread(()->{
System.out.println("new thread:"+local.get());
}).start();
TimeUnit.SECONDS.sleep(1);
System.out.println("main thread:"+local.get());
}
}
  • 输出结果

main thread:main
new thread:null

实现原理

  • 在Thread中维护着ThreadLocal.ThreadLocalMap threadLocals 成员变量

  • 在ThreadLocal.ThreadLocalMap中以**ThreadLocal.threadLocalHashCode* *来为基础算出key包缓存相应的value,以区分不同ThreadLocal的变量。

ThreadLocal只是维护着变量的引用,引用的key是弱引用,弱引用只存在于key上,所以key会被回收. 而value还存在着强引用.只有thread退出以后,value的强引用链条才会断掉

  • ThreadLocal需要注意的问题,每次执行完毕后,要使用remove() 方法来清空对象,否则 ThreadLocal 存放大对象后,会出现OMM。

  • ThreadLocal要使用static的 ,在其他地方可以直接用get 和 set方法。

ThreadLocal内存泄漏

ThreadLocalMap使用ThreadLocal的弱引用作为key,如果一个ThreadLocal没有外部强引用来引用它,那么系统 GC 的时候,这个ThreadLocal势必会被回收,这样一来,ThreadLocalMap中就会出现key为null的Entry,就没有办法访问这些key为null的Entry的value,如果当前线程再迟迟不结束的话,这些key为null的Entry的value就会一直存在一条强引用链:Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value 永远无法回收,造成内存泄漏。

其实,ThreadLocalMap的设计中已经考虑到这种情况,也加上了一些防护措施:在ThreadLocal的get(),set(),remove()的时候都会清除线程ThreadLocalMap里所有key为null的value。

但是这些被动的预防措施并不能保证不会内存泄漏:

  • 使用static的ThreadLocal,延长了ThreadLocal的生命周期,可能导致的内存泄漏(参考ThreadLocal 内存泄露的实例分析)。

  • 分配使用了ThreadLocal又不再调用get(),set(),remove()方法,那么就会导致内存泄漏。

为什么使用弱引用

为什么使用弱引用?

  • 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就会导致内存泄漏,而不是因为弱引用。

综合上面的分析,我们可以理解ThreadLocal内存泄漏的前因后果,那么怎么避免内存泄漏呢?

  • 每次使用完ThreadLocal,都调用它的remove()方法,清除数据。

在使用线程池的情况下,没有及时清理ThreadLocal,不仅是内存泄漏的问题,更严重的是可能导致业务逻辑出现问题。所以,使用ThreadLocal就跟加锁完要解锁一样,用完就清理。

InheritableThreadLocal

与ThreadLocal不同的是InheritableThreadLocal是可以被继承的,InheritableThreadLocal在Thread中同样是维护着一个成员变量inheritableThreadLocals

  • demo如下:

import java.util.concurrent.TimeUnit;
public class ThreadLocalDemo {
static ThreadLocal<String> local = new InheritableThreadLocal<>();
public static void main(String[] args) throws InterruptedException {
local.set("main");
new Thread(()->{
System.out.println("new thread:"+local.get());
}).start();
TimeUnit.SECONDS.sleep(1);
System.out.println("main thread:"+local.get());
}
}
  • 结果

new thread:main
main thread:main
原理

我们在new一个线程的时候

public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}

然后

private void init(ThreadGroup g, Runnable target, String name,
long stackSize) {
init(g, target, name, stackSize, null);
}

接下来

private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc) {
......
if (parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
/* Stash the specified stack size in case the VM cares */
this.stackSize = stackSize;
......
}
}

这时候有一句ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); ,然后

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
return new ThreadLocalMap(parentMap);
}



private ThreadLocalMap(ThreadLocalMap parentMap) {
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
@SuppressWarnings("unchecked")
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
if (key != null) {
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}

当我们创建一个新的线程X的时候,X线程就会有ThreadLocalMap类型的inheritableThreadLocals ,因为它是 Thread 类的一个属性。这样就先得到当前线程存储的这些值,例如 Entry[] parentTable = parentMap.table; 。再通过一个 for 循环,不断的把当前线程的这些值复制到我们新创建的线程X 的inheritableThreadLocals中。



关注我,发现更多Java领域知识



发布于: 2020 年 05 月 20 日 阅读数: 61
用户头像

JFound

关注

梳理java知识,发现Java相关的更多领域知识 2020.05.19 加入

Java技术栈奋斗者

评论

发布
暂无评论
深入剖析ThreadLocal原理