ThreadLocal底层实现原理

daiwei-dave

已于 2022-10-23 18:48:30 修改

阅读量4.1k

点赞数 2

分类专栏： java并发文章标签：多线程

于 2021-03-21 23:54:25 首次发布

本文链接：https://blog.csdn.net/sinat_34814635/article/details/115058616

版权

java并发专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、基础概念

ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量，使线程之间相互独立互不影响

1.1 同步机制的比较

对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。
前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

Threadlocal的最大作用就是代替同步锁，提高相关性能。

与volatile关键字的对比

在并发编程中，多个线程访问同一个变量，可能读到另一个线程修改后的值，也可能不是修改后的值。

所以volatile保证我读到的是最新的值，而ThreadLocal保证我读到的是不会被其他线程影响到的值。

1.2 使用场景（多用于全局变量）

1.日志统计：计算接口调用耗时时，缓存当前的开始时间，和请求id

2.读写分离时，缓存读写标志。

3.数据库连接管理

private static ThreadLocal<Connection> connectionHolder= new ThreadLocal<Connection>() {
public Connection initialValue() {
    return DriverManager.getConnection(DB_URL);
}
};
 
public static Connection getConnection() {
return connectionHolder.get();
}

4.Session管理

private static final ThreadLocal threadSession = new ThreadLocal();
 
public static Session getSession() throws InfrastructureException {
    Session s = (Session) threadSession.get();
    try {
        if (s == null) {
            s = getSessionFactory().openSession();
            threadSession.set(s);
        }
    } catch (HibernateException ex) {
        throw new InfrastructureException(ex);
    }
    return s;
}

5.调用链（参数传递）

如在公司设置的适配器功能

设置cxGoodsPurchasesFromDubboList

@Slf4j
@Component
public class CxGoodsPurchasesDtoAdapter implements CxGoodsPurchasesDtoTarget {

    private final ThreadLocal<List<CxGoodsPurchasesFromDubbo>> adaptResultContext = new ThreadLocal<>();

    @Resource
    private CxCommonBO cxCommonBO;

    @Resource
    private CxMartRService cxMartRService;

    private List<CxGoodsPurchasesFromDubbo> cxGoodsPurchasesFromDubboList;

    @Override
    public void adaptFromDubbo(List<CxGoodsPurchasesInfo> req) {
        try {
            log.info("=============start invoke method CxGoodsPurchasesDtoAdapter adaptFromDubbo,param={}", JsonUtils.toJsonTrim(req));
            if (CollectionUtils.isEmpty(req)) {
                return;
            }
            cxGoodsPurchasesFromDubboList = new ArrayList<>();
            for (CxGoodsPurchasesInfo cxGoodsPurchasesInfo : req) {
                CxGoodsPurchasesFromDubbo cxGoodsPurchasesFromDubbo = new CxGoodsPurchasesFromDubbo();
                cxGoodsPurchasesFromDubbo.setGoodsCode(cxGoodsPurchasesInfo.getGoodsCode());
                cxGoodsPurchasesFromDubbo.setGoodsName(cxGoodsPurchasesInfo.getGoodsName());
                cxGoodsPurchasesFromDubbo.setSkuId(cxGoodsPurchasesInfo.getSkuId());
                cxGoodsPurchasesFromDubbo.setBarCode(cxGoodsPurchasesInfo.getBarCode());
                cxGoodsPurchasesFromDubbo.setBaseUnit(cxGoodsPurchasesInfo.getBaseUnit());
                cxGoodsPurchasesFromDubbo.setTaxCode(cxGoodsPurchasesInfo.getTaxCode());
                cxGoodsPurchasesFromDubbo.setTaxRatio(cxGoodsPurchasesInfo.getTaxRatio());
                cxGoodsPurchasesFromDubbo.setWeight(cxGoodsPurchasesInfo.getWeight());

                cxGoodsPurchasesFromDubbo.setWareTypeCode(cxGoodsPurchasesInfo.getWareTypeCode());
                cxGoodsPurchasesFromDubbo.setSource(cxGoodsPurchasesInfo.getSource());
                cxGoodsPurchasesFromDubbo.setSupplierCode(cxGoodsPurchasesInfo.getSupplierCode());
                List<CatFrameworkLevel> catFrameworkLevels = cxGoodsPurchasesInfo.getCatFrameworkLevels();
                setCategoryCode(cxGoodsPurchasesFromDubbo, catFrameworkLevels);
                setCxGoodsMdl(cxGoodsPurchasesFromDubbo, cxGoodsPurchasesInfo);
                cxGoodsPurchasesFromDubboList.add(cxGoodsPurchasesFromDubbo);
            }
            adaptResultContext.set(cxGoodsPurchasesFromDubboList);
            log.info("adaptResultContext set success,currentThread={}", Thread.currentThread());
        } catch (Exception e) {
            log.error("invoke method CxGoodsPurchasesDtoAdapter adaptFromDubbo occur error", e);
        }
    }

取cxGoodsPurchasesFromDubboList

@CxRouter
@Slf4j
public class CxGoodsHandler implements Handler {

    @Resource
    protected CxGoodsRService cxGoodsRService;
    @Resource
    private CxPurchasesConfigService cxPurchasesConfigService;
    @Resource
    private CxCommonBO cxCommonBO;

    @Resource
    private CxGoodsPurchasesDtoAdapter cxGoodsPurchasesDtoAdapter;

    @Resource
    private CxGoodsFallbackLogsService cxGoodsFallbackLogsService;

    @Override
    public void handle(List<CxGoodsPurchasesDTO> datas) {

        List<CxGoodsPurchasesFromDubbo> cxGoodsPurchasesFromDubboList = cxGoodsPurchasesDtoAdapter.getAdaptResult();
        if (CxCollectionUtils.isEmpty(cxGoodsPurchasesFromDubboList)) {
            log.info("cxGoodsPurchasesDtoAdapter getAdaptResult is Empty,start invoke method doInvokeGoodsInterface");
            doInvokeGoodsInterface(datas);
            return;
        }
        doSetGoodsFromDubbo(datas, cxGoodsPurchasesFromDubboList);
        log.info("=============after invoke method CxGoodsHandler handle,result={}", JsonUtils.toJsonTrim(datas));

    }

二、底层原理分析

2.1 java.lang.Thread#threadLocals属性

每一个Thread 对象均含有一个ThreadLocalMap 类型的成员变量threadLocals ，它存储本线程中所有ThreadLocal对象及其对应的值。

Thread类有一个核心属性threadLocals，这个threadLocals就是用来存储当前线程变量和对应副本值的映射关系的。即让threadLocals引用指向key为threadLocal，value为当前线程的值。

其中键值为当前ThreadLocal变量(该变量与当前线程有关但不是当前线程值)，value为变量副本（即T类型的变量的值）。源码如下：

/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

注意：是Thread类有一个threadLocals变量，而不是ThreadLocal类有threadLocals变量（之前理解搞反了）

2.2 java.lang.ThreadLocal.ThreadLocalMap

/**
     * ThreadLocalMap is a customized hash map suitable only for
     * maintaining thread local values. No operations are exported
     * outside of the ThreadLocal class. The class is package private to
     * allow declaration of fields in class Thread.  To help deal with
     * very large and long-lived usages, the hash table entries use
     * WeakReferences for keys. However, since reference queues are not
     * used, stale entries are guaranteed to be removed only when
     * the table starts running out of space.
     */
    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 由一个个Entry 对象构成。

Entry 继承自WeakReference<ThreadLocal<?>> ，一个Entry 由ThreadLocal 对象和Object 构
成。由此可见， Entry 的key是ThreadLocal对象，并且是一个弱引用。当没指向key的强引用后，该key就会被垃圾收集器回收，而value为变量值。

2.3 ThreadLocal是如何为每个线程创建变量的副本的

初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。

然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。

注意：

1.在进行get之前，必须先set，否则会报空指针异常；如果想在get之前不需要调用set就能正常访问的话，必须重写initialValue()方法。

2.3.1 set方法

当执行set方法时，ThreadLocal首先会获取当前线程对象，然后获取当前线程的ThreadLocalMap类型对象。再以当前ThreadLocal对象为key，将值存储进ThreadLocalMap类型对象中。

set方法主要就是初始化threadLocals，不同的线程会new出不同的ThreadLocalMap

/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

可以看到，set(T value)方法为每个Thread对象都创建了一个ThreadLocalMap，并且将value放入ThreadLocalMap中，ThreadLocalMap作为Thread对象的成员变量保存。

2.3.2 get()方法源码分析：

get方法执行过程类似。ThreadLocal首先会获取当前线程对象，然后获取当前线程的ThreadLocalMap对象。再以当前ThreadLocal对象为key，获取对应的value。

/**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    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();
    }

     /**
     * 获取当前ThreadLocalMap
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }


     /**
     *   初始化threadLocals
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }



    /**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
     */
    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }






     /**
     * 初始值为空，若想不为空，则需客户端重写
     * Returns the current thread's "initial value" for this
     * thread-local variable.  This method will be invoked the first
     * time a thread accesses the variable with the {@link #get}
     * method, unless the thread previously invoked the {@link #set}
     * method, in which case the {@code initialValue} method will not
     * be invoked for the thread.  Normally, this method is invoked at
     * most once per thread, but it may be invoked again in case of
     * subsequent invocations of {@link #remove} followed by {@link #get}.
     *
     * <p>This implementation simply returns {@code null}; if the
     * programmer desires thread-local variables to have an initial
     * value other than {@code null}, {@code ThreadLocal} must be
     * subclassed, and this method overridden.  Typically, an
     * anonymous inner class will be used.
     *
     * @return the initial value for this thread-local
     */
    protected T initialValue() {
        return null;
    }

我们发现如果没有先set的话，即在map中查找不到对应的存储，则会通过调用setInitialValue方法返回i，而在setInitialValue方法中，有一个语句是T value = initialValue()，

而默认情况下，initialValue方法返回的是null。

重写逻辑可以参考如下：

ThreadLocal<Long> longLocal = new ThreadLocal<Long>(){
        protected Long initialValue() {
            return Thread.currentThread().getId();
        };
    };
    ThreadLocal<String> stringLocal = new ThreadLocal<String>(){;
        protected String initialValue() {
            return Thread.currentThread().getName();
        };
    };

2.3.3 ThreadLocal的remove方法

 /**
     * Removes the current thread's value for this thread-local
     * variable.  If this thread-local variable is subsequently
     * {@linkplain #get read} by the current thread, its value will be
     * reinitialized by invoking its {@link #initialValue} method,
     * unless its value is {@linkplain #set set} by the current thread
     * in the interim.  This may result in multiple invocations of the
     * {@code initialValue} method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }



/**
         * Remove the entry for key.
         */
        private void remove(ThreadLocal<?> key) {
            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)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

ThreadLocal的remove()方法会先将Entry中对key的弱引用断开，设置为null，然后再清除对应的key为null的value。

2.4 ThreadLocal与内存泄漏

2.4.1内存泄漏的原因

ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，Key(ThreadLocal)势必会被GC回收，这样就会导致ThreadLocalMap中key为null，而value还存在着强引用，只有thead线程退出以后,value的强引用链条才会断掉，但如果当前线程再迟迟不结束的话(如用线程池进行管理的dubbo线程等)，这些key为null的Entry的value就会一直存在一条强引用链（红色链条）

下图可以更直接的表示。其中虚线表示弱引用

è¿éåå¾çæè¿°

下图虚线表示弱引用。ThreadLocal对象被GC回收了，那么key变成了null。Map又是通过key拿到的value的对象。

所以，GC在回收了key所占内存后，没法访问到value的值，因为需要通过key才能访问到value对象。另外，如图所示的引用链：CurrentThread -- Map -- Entry -- value ，所以，在当前线程没有被回收的情况下，value所占内存也不会被回收。所以可能会造成了内存溢出。

参考：

1.ThreadLocal内存泄露 ThreadLocal内存泄露_小大宇的博客-CSDN博客_threadlocal 泄露

ThreadLocal原理及内存泄露预防_puppylpg的博客-CSDN博客_threadlocal内存泄漏

ThreadLocal内存溢出问题_幽夜落雨的博客-CSDN博客

2.4.2 如何防止内存泄漏

因为上述的原因，在ThreadLocal这个类的get（）、set（）、remove（）方法，均有实现回收 key 为 null 的 Entry 的 value所占的内存。

所以，为了防止内存泄露（没法访问到的内存），在不会再用ThreadLocal的线程任务末尾，调用一次上述三个方法的其中一个即可，一般使用remove。

思考

1.threadLocal是如何保证线程之间的值，互相独立的？

由于每一条线程均含有各自私有的ThreadLocalMap容器，这些容器相互独立互不影响，因此不会存在线程安全性问题，从而也无需使用同步机制来保证多条线程访问容器的互斥性。

ThreadLocal对象每次调用set方法，都是设置的是当前线程的threadLocals变量的值。

调用get方法时也是获取当前线程的threadLocals变量。

即ThreadLocalMap对象不一样，且在set/get方法时都按照当前线程设置和获取的。比如线程1的threadLocals变量和线程2threadLocals变量肯定是不同的。

2.ThreadLocal是否会造成内存溢出？

我认为很难造成内存溢出，因为ThreadLocalMap中的Entry继承了WeakReferenc。但可能造成内存泄露。

3.如果key 使用强引用会怎样？

当threadLocalMap的key为强引用回收ThreadLocal时，因为ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除或线程没有退出（被线程池管理），ThreadLocal不会被回收，那么将一直占用内存，同样可能导致内存泄漏。并且当前线程很有可能取到之前同名线程的值，造成数据紊乱。

所以使用强引用并不会回收掉ThreadLocal的内存，反而会影响线程之间的相互隔离

@see 14.Java并发编程：深入剖析ThreadLocalhttp://www.cnblogs.com/dolphin0520/p/3920407.html

@see ThreadLocal源码解读http://www.cnblogs.com/micrari/p/6790229.html

4.duboo中使用Threadlocal

首先ThreadLocal是跟着线程走的，而不管是dubbo或者其他的rpc框架或者Springmvc都有个特点：使用的是线程池模型，当线程执行任务结束之后会回到线程池，这时如果在回到线程池之前ThreadLocal没有被清理，当下一次请求拿到这个线程的时候还能读取到之前没有被清理的ThreadLocal的数据，这样显然不是我们想要的结果了。

在 Dubbo 中使用 ThreadLocal ，如果采用默认的设置，每次 Dubbo 调用结束，Dubbo 处理响应线程并不会被销毁，而是归还到线程池中。而从 ThreadLocal 源码可以看出，每次我们设置的值其实会存在位于 Thread 中 ThreadLocalMap 变量中。

这就导致，下次如果 Dubbo 处理响应恰好继续使用到这个线程，该线程就能调用到上次响应中设置在 ThreadLocal 设置的值。这会导致业务上异常。其实并不止在 Dubbo 中，该案例还会发生在 web项目中，只要相关使用线程池的，都有可能发生。

daiwei-dave

关注

2
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal底层实现原理

一、基础概念ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。1.1 同步机制的比较对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。与volatile关键字的对比在并发编程中，多个线程访问同一个变量，可能读到另一个线程修改后的值，也可能不是修改后的值。所.
复制链接

扫一扫