深入剖析 ThreadLocal 原理

 关注
发布于: 2020 年 05 月 20 日
描述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
原文链接:【http://xie.infoq.cn/article/d42e34e430a98e791b8db2c15】。文章转载请联系作者。
JFound

 关注
梳理java知识，发现Java相关的更多领域知识 2020.05.19 加入
Java技术栈奋斗者
发布
暂无评论