前言
工作中用到了ThreadLocal,觉得非常巧妙好用,顾总结下
ThreadLocal 通常使用场景
- 在进行对象跨层传递的时候,使用ThreadLocal可以避免多次传递,打破层次间的约束
- 线程间数据隔离
- 进行事务操作,用于存储线程事务信息。
- 数据库连接,Session会话管理。
工作中就是利用了ThreadLocal省去了频繁的传递参数。
使用
先写一个工具类
public class VersionHodler {
private static ThreadLocal<docVersion> docVersionMap = new ThreadLocal<>();
public static void setVersionMap(docVersion versionMap){
docVersionMap.set(versionMap);
}
public static docVersion getVersionMap(){
return docVersionMap.get();
}
//用完清除避免内存泄漏
public static void clear(){
topicDocVersionMap.remove();
}
//传递一个内部类作为介质
public static class DocVersion{
private Integer finishStatus;
private Integer topicVersion;
public Integer getFinishStatus() {
return finishStatus;
}
public void setFinishStatus(Integer finishStatus) {
this.finishStatus = finishStatus;
}
public Integer getTopicVersion() {
return topicVersion;
}
public void setTopicVersion(Integer topicVersion) {
this.topicVersion = topicVersion;
}
}
}
使用时 ,先在需要传递参数的业务代码那里设值:
//这里省略业务代码,如某个controller调用了n多逻辑,controller-->service1-->service2-->dao-->某save方法
try {
VersionHodler.DocVersion docVersion = new VersionHodler.docVersion();
docVersion.setFinishStatus(xxx.getFinishStatus());
docVersion.setTopicVersion(xxx.getTopicVersion());
VersionHodler.setVersionMap(docVersion);
}
finally {
VersionHodler.clear();
}
最后需要在使用这个变量的地方,如某save方法中:
//先把变量取出来
VersionHodler.DocVersion docVersion = VersionHodler.getVersionMap();
//执行代码
最后,好处应该可以看到了controller-->service1-->service2-->dao-->某save方法
当中不需要传递参数,直接在需要取参数的地方就能取到,避免频繁的传递参数,也没有使用到锁机制。如果某场景下代码量已经很多 ,后期由于某个需求需要添加一个参数,那么这个改动量是非常大的。
内存泄漏问题
使用完ThreadLocal后,执行remove操作,避免出现内存溢出情况。
为什么会内存溢出呢?看源码(jdk1.8)~
1.首先看ThreadLocal里面保存的是什么值。看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);
}
首先获取到了当前线程t,然后调用getMap获取ThreadLocalMap,如果map存在,则将当前线程对象t作为key,要存储的对象作为value存到map里面去。如果该Map不存在,则初始化一个。
2.再看ThreadLocalMap是什么
static class ThreadLocalMap {
/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object). Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table. Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
//... 省略
}
ThreadLocalMap其实就是ThreadLocal的一个静态内部类,里面定义了一个Entry来保存数据,而且还是继承的弱引用。在Entry内部使用ThreadLocal作为key,使用我们设置的value作为value。
还有一个getMap
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
调用当期线程t,返回当前线程t中的成员变量threadLocals。而threadLocals其实就是ThreadLocalMap。
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();
}
首先获取当前线程,然后调用getMap方法获取一个ThreadLocalMap,如果map不为null,那就使用当前线程作为ThreadLocalMap的Entry的键,然后值就作为相应的的值,如果没有那就设置一个初始值。
内存泄漏的原因
- Thread中有一个map,就是ThreadLocalMap
- ThreadLocalMap的key是ThreadLocal,值是我们自己设定的。
- ThreadLocal是一个弱引用,当为null时,会被当成垃圾回收
- 如果突然我们ThreadLocal是null了,也就是要被垃圾回收器回收了,但是此时我们的ThreadLocalMap生命周期和Thread的一样(注意这几个变量生命周期不一样,品一下),它不会回收,这时候就出现了一个现象。那就是ThreadLocalMap的key没了,但是value还在,这就造成了内存泄漏。
解决办法:使用完ThreadLocal后,执行remove操作,避免出现内存溢出情况。
额外加深理解Java内的四大引用
- 强引用:强引用是使用最普通的应用。如果一个对象具有强引用,那么gc绝
不会回收
它。当内存空间不足,java虚拟机宁愿抛出OOM(OutOfMemory),使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。 - 软引用:如果一个对象具有软引用,在JVM发生内存溢出之前(即内存充足够使用),是不会GC这个对象的;
只有到JVM内存不足的时候才会调用垃圾回收期回收掉这个对象
。软引用和一个引用队列联合使用,如果软引用所引用的对象被回收之后,该引用就会加入到与之关联的引用队列中。(软引用可以用来实现内存敏感的高速缓存
) - 弱引用:这里讨论ThreadLocalMap中的Entry类的重点,如果一个对象只具有弱引用,那么这个对象就会被垃圾回收器回收掉(被弱引用所引用的对象只能生存到下一次GC之前,
当发生GC时候,无论当前内存是否足够,弱引用所引用的对象都会被回收掉
)。弱引用也是和一个引用队列联合使用,如果弱引用的对象被垃圾回收期回收掉,JVM会将这个引用加入到与之关联的引用队列中。若引用的对象可以通过弱引用的get方法得到,当引用的对象被回收掉之后,再调用get方法就会返回null。 - 虚引用:虚引用是所有引用中最弱的一种引用,其存在就是为了将关联虚引用的对象在被GC掉之后收到一个通知。
软引用作为缓存demo
public class SoftReferenceDemo {
//private static ConcurrentHashMap<String,SoftReference<User>> cacheUser = new ConcurrentHashMap<String,SoftReference<User>>();
public static void main(String[] args) throws InterruptedException {
User a = new User();
a.name = "wei";
SoftReference<User> softReference = new SoftReference<User>(a);
a = null;
System.out.println(softReference.get().name);
int i = 0;
while (softReference.get() != null) {
if (i == 10) {
System.gc();
System.out.println("GC");
}
Thread.sleep(1000);
System.out.println(i);
i++;
}
System.out.println("Finish");
}
}