ThreadLocal、MDC线程池传递和自动清理

最新推荐文章于 2024-09-09 05:15:00 发布
最新推荐文章于 2024-09-09 05:15:00 发布
阅读量3.5k 收藏 3
点赞数 2
文章标签： java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yu542771572/article/details/116723960
版权

一、背景

比如TraceId、UserContext、RequestContext需要在线程池进行传递和清理

二、实现

  1. 统一的ThreadLocal垃圾回收
public class ThreadLocalCleaner {

    private static final List<ThreadLocal<?>> CONTAINER = Lists.newArrayList();

    public static void register(ThreadLocal<?>... threadLocal) {
        if(ArrayUtils.isNotEmpty(threadLocal)) {
            CONTAINER.addAll(Arrays.asList(threadLocal));
        }
    }

    public static void register(List<ThreadLocal<?>> threadLocal) {
        if(!CollectionUtils.isEmpty(threadLocal)) {
            CONTAINER.addAll(threadLocal);
        }
    }

    public static void clear() {
        CONTAINER.forEach(ThreadLocal::remove);
    }

}
  1. 统一ThreadLocal存储
@SuppressWarnings("unchecked")
public final class ThreadLocalManager {

    private ThreadLocalManager() { }

    private static final List<ThreadLocal<?>> THREAD_LOCALS = Lists.newArrayList();
    private static final ThreadLocal<Map<String, Object>> CONTAINER = ThreadLocal.withInitial(HashMap::new);

    static {
        ThreadLocalCleaner.register(CONTAINER);
        ThreadLocalCleaner.register(THREAD_LOCALS);
    }

    /**
     * @return threadLocal中的全部值
     */
    public static Map<String, Object> getAll() {
        return new HashMap<>(CONTAINER.get());
    }

    /**
     * 将ThreadLocal纳入ThreadLocalManager管理
     *
     * @param threadLocalContext threadLocal对象
     */
    public static void register(ThreadLocal<?> threadLocalContext) {
        THREAD_LOCALS.add(threadLocalContext);
    }

    /**
     * 获取threadLocal键值集合
     *
     * @return  threadLocal键值集合
     */
    public static Map<ThreadLocal<?>, ?> getCopyThreadLocalMap() {
        return THREAD_LOCALS.stream().collect(Collectors.toMap(o -> o, ThreadLocal::get));
    }

    /**
     * 设置一个值到ThreadLocal
     * 注意：最好加上业务前缀保证key不会重复！
     *
     * @param key   键
     * @param value 值
     * @param <T>   值的类型
     * @return 被放入的值
     * @see Map#put(Object, Object)
     */
    public static <T> T put(String key, T value) {
        CONTAINER.get().put(key, value);
        return value;
    }

    /**
     * 设置所有制到ThreadLocal
     * 注意：最好加上业务前缀保证key不会重复！
     *
     * @param kv 键值
     */
    public static void putAll(Map<String, Object> kv) {
        CONTAINER.get().putAll(kv);
    }

    /**
     * 删除参数对应的值
     *
     * @param key
     * @see Map#remove(Object)
     */
    public static void remove(String key) {
        CONTAINER.get().remove(key);
    }

    /**
     * 清空ThreadLocal
     *
     * @see Map#clear()
     */
    public static void clear() {
        CONTAINER.remove();
    }

    /**
     * 从ThreadLocal中获取值
     *
     * @param key 键
     * @param <T> 值泛型
     * @return 值, 不存在则返回null, 如果类型与泛型不一致, 可能抛出{@link ClassCastException}
     * @see Map#get(Object)
     * @see ClassCastException
     */
    public static <T> T get(String key) {
        return ((T) CONTAINER.get().get(key));
    }

    /**
     * 从ThreadLocal中获取值,并指定一个当值不存在的提供者
     *
     * @see Supplier
     */
    public static <T> T get(String key, Supplier<T> supplierOnNull) {
        return ((T) CONTAINER.get().computeIfAbsent(key, k -> supplierOnNull.get()));
    }

    /**
     * 获取一个值后然后删除掉
     *
     * @param key 键
     * @param <T> 值类型
     * @return 值, 不存在则返回null
     * @see this#get(String)
     * @see this#remove(String)
     */
    public static <T> T getAndRemove(String key) {
        try {
            return get(key);
        } finally {
            remove(key);
        }
    }

}
  1. 扩展Runnable和Callable
public class TransferCallable<T> implements Callable<T> {

    private Callable<T> callable;
    private Map<String, String> mdcContext;
    private Map<String, Object> threadLocalContext;
    private Map<ThreadLocal<?>, ?> threadLocalMap;

    public TransferCallable(Callable<T> callable, Map<String, String> mdcContext,
                       Map<String, Object> threadLocalContext, Map<ThreadLocal<?>, ?> threadLocalMap) {
        this.callable = callable;
        this.mdcContext = mdcContext;
        this.threadLocalContext = threadLocalContext;
        this.threadLocalMap = threadLocalMap;
    }

    @Override
    @SuppressWarnings("all")
    public T call() throws Exception {
        Map<String, String> previous = MDC.getCopyOfContextMap();
        if (mdcContext == null) {
            MDC.clear();
        } else {
            MDC.setContextMap(mdcContext);
        }

        for (Map.Entry<ThreadLocal<?>, ?> entry : threadLocalMap.entrySet()) {
            ThreadLocal key = entry.getKey();
            key.set(entry.getValue());
        }

        ThreadLocalManager.putAll(threadLocalContext);
        try {
            return callable.call();
        } finally {
            if (previous == null) {
                MDC.clear();
            } else {
                MDC.setContextMap(previous);
            }

            ThreadLocalManager.clear();
            threadLocalMap.keySet().forEach(ThreadLocal::remove);
        }
    }
}


public class TransferRunnable implements Runnable{

    private Runnable runnable;
    private Map<String, String> mdcContext;
    private Map<String, Object> threadLocalContext;
    private Map<ThreadLocal<?>, ?> threadLocalMap;

    public TransferRunnable(Runnable runnable, Map<String, String> mdcContext,
                       Map<String, Object> threadLocalContext, Map<ThreadLocal<?>, ?> threadLocalMap) {
        this.runnable = runnable;
        this.mdcContext = mdcContext;
        this.threadLocalContext = threadLocalContext;
        this.threadLocalMap = threadLocalMap;
    }

    @Override
    @SuppressWarnings("all")
    public void run() {
        Map<String, String> previous = MDC.getCopyOfContextMap();
        if (mdcContext == null) {
            MDC.clear();
        } else {
            MDC.setContextMap(mdcContext);
        }

        for (Map.Entry<ThreadLocal<?>, ?> entry : threadLocalMap.entrySet()) {
            ThreadLocal key = entry.getKey();
            key.set(entry.getValue());
        }
        ThreadLocalManager.putAll(threadLocalContext);
        try {
            runnable.run();
        } finally {
            if (previous == null) {
                MDC.clear();
            } else {
                MDC.setContextMap(previous);
            }

            ThreadLocalManager.clear();
            threadLocalMap.keySet().forEach(ThreadLocal::remove);
        }
    }
}
  1. ThreadPoolTaskExecutor的task包装
public class TransferTaskDecorator implements TaskDecorator {

    @Override
    public Runnable decorate(Runnable runnable) {
        return new TransferRunnable(runnable, MDC.getCopyOfContextMap(), ThreadLocalManager.getAll(), ThreadLocalManager.getCopyThreadLocalMap());
    }
}
  1. ThreadLocal自动清理
public class ThreadLocalCleanInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return super.preHandle(request, response, handler);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        ThreadLocalCleaner.clear();
        super.afterCompletion(request, response, handler, ex);
    }

}
  1. 异步线程池配置
    @Bean("asyncExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(4);
        executor.setMaxPoolSize(8);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix("asyncExecutor-");
        executor.setTaskDecorator(new TransferTaskDecorator());
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(30);
        return executor;
    }
  1. 使用方式
public class UserContext {

    private static final String KEY = "USR_ACCOUNT";

    public static UserInfo getUser() {
        return ThreadLocalManager.get(KEY);
    }

    public static void setUser(UserInfo userInfo) {
        ThreadLocalManager.put(KEY, userInfo);
    }

    public static void remove() {
        ThreadLocalManager.remove(KEY);
    }

}

三、注意事项

  • 定时任务不支持ThreadLocal自动回收
  • 可以对@Scheduled进行切面然后finally中回收
  • 更加方便的方式可以使用阿里的transmittable-thread-local的插件
  • 也可以参考开源调用链路监测用agent对字节码进行编辑
yu542771572
关注
log(二)——MDC实现之ThreadLocal
xxcupid的博客
07-19 3125
因为MDC底层是用ThreadLocal实现的，所以这里补充一些和ThreadLocal相关的知识点。 1.ThreadLocal的三个层次 关于ThreadLocal有三个层次，可以按照这三个层次去理解就不会乱。 三个层次  * 第一层是Thread空间  * 第二层是Thread中的两个ThreadLocalMap，threadLocals和inheritableThreadLoca
slf4j的MDC对象和ThreadLocal简单分析
m0_37811464的博客
09-18 3645
MDC（Mapped Diagnostic Context，映射调试上下文）是 log4j 和 logback 提供的一种方便在多线程条件下记录日志的功能。某些应用程序采用多线程的方式来处理多个用户的请求。在一个用户的使用过程中，可能有多个不同的线程来进行处理。典型的例子是 Web 应用服务器。当用户访问某个页面时，应用服务器可能会创建一个新的线程来处理该请求，也可能从线程池中复用已有的线程。在一...
ThreadLocal 释放的方式有哪些
最新发布
程序猿进阶
09-09 1412
创建一个自定义的，在创建线程时添加钩子，以便在任务完成后清理变量。搭建统一线程池平台，对该部分进行了改造。提供多个工厂，就包含自动清理工厂。// 清理ThreadLocal变量 ThreadLocalHolder . clear();} });// 清理ThreadLocal变量 ThreadLocalHolder . clear();} });
MDC、ThreadLocal、InheritableThreadLocal的区别和联系
背着梦的幸存者
11-10 1384
ThreadLocal使用来存储线程本地变量的。MDC的底层使用的就是ThreadLocal来存储的，只不过是做了一些安全校验，如MDC取值时ThreadLocalMap==null怎么办。InheritableThreadLocal支持子线程继承父线程中的thread-local值。留个问题哈：现在项目中很多使用多线程的地方都是使用的线程池，线程池中的线程并不具备父子关系，这样threadlocal怎么传递？
ThreadLocal&MDC内存泄漏问题
xiexiaojing的博客
12-25 3997
在《大话高可用》里，之前的老大有过总结，高可用就是：别人死我们不死，自己不作死，不被别人搞死。这段时间，网上都在传Log4j2的lookup远程执行代码漏洞。这个漏洞要想造成危害，基本都是...
ThreadLocal
weixin_40961551的博客
05-15 1378
ThreadLocal原理API场景使用ThreadLocal思路代码 原理 ThreadLocal只有当前线程可以访问，每个线程都有自己的变量副本。线程消亡他也消亡，他是变量对象，不是线程。 其中存储的内容只有当前线程能访问的 API void set(T value) 设置当前线程的threadlocal的值 T get() 该方法返回当前线程threadlocal的值 void removed() 将当前线程threadlocal的值删除。 目的是为了减少内存的占用。需要指出的是,当线程结束后,
Hystrix传递ThreadLocal范围对象的问题(最为细致的分析)
guntun8987的博客
04-19 627
Hystrix传递ThreadLocal范围对象的问题
ThreadLocal的作用和原理
分享身边生活经验blog
06-24 479
ThreadLocal可以称为线程本地变量或线程本地存储，跟方法内作用域的变量一样，都是本线程私有的。可以用来在一个线程调用多个方法的过程中、用来传递参数，省去通过方法入参传递的麻烦。slfj的MDC，多数据源，以及弱引用WeakReference等等场景中都可以看到ThreadLocal的应用。 线程本地存储：在线程生命周期内作为上下文存储共享对象 这里的上下文指的是线程存活期间内，调用多个方法，各个方法之间共享的“上下文空间”。 我们知道，每个线程对应着它的线程栈，线程栈由栈帧组成，用这套数据结构
万字长文带你深入理解ThreadLocal！ThreadLocal超详细解析！
Viper的程序员修炼手册
08-23 1090
前言 对于ThreadLocal，大家的第一反应可能是很简单呀，线程的变量副本，每个线程隔离。那这里有几个问题大家可以思考一下： ThreadLocal的key是弱引用，那么在 threadLocal.get()的时候,发生GC之后，key是否为null？ ThreadLocal中ThreadLocalMap的数据结构？ ThreadLocalMap的Hash算法？ ThreadLocalMap中Hash冲突如何解决？ ThreadLocalMap扩容机制？ ThreadLocalMap中过期key的清理
SLF4J与MDC：上下文信息传递解决方案，专家分享
SLF4J与MDC概述 SLF4J（Simple Logging Facade for Java）是一个用于Java应用程序的日志框架的抽象层。它提供了统一的日志API，使得开发者可以在后台随意切换不同的日志实现，如Logback, Log4j等，而不影响代码的...
【Java多线程】ThreadLocal 原理分析与使用场景
墩墩分墩
06-05 688
面试官：听说你看过ThreadLocal源码？我来瞅瞅？ Java并发之ThreadLocal 一文搞懂 ThreadLocal 原理 Java中ThreadLocal 原理分析与使用场景 ThreadLocal就是这么简单 再也不学ThreadLocal了，看这一篇就忘不掉了！（万字总结） 线程安全性？如何安全地使用 ThreadLocal ThreadLocal 和神奇的数字 0x61c88647 面试再问ThreadLocal，别说你不会 ThreadLocal可以解决并发问题吗 面试官再问你 Thr
Spring AOP的接口耗时统计
dengyiyu5280的博客
09-06 429
Spring AOP的接口耗时统计 /*** 通知* * @author wwl**/public class ActionAdvice implements MethodInterceptor { private Log log=LogFactory.getLog(ActionAdvice.class); @Override public Object i...
spring aop切面应用，记录日志、请求处理耗时
hgg923的专栏
05-25 6147
依赖jar包 aopalliance.jar、aspectjrt.jar、aspectjweaver-1.6.jar spring配置文件（标红部分）： <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:
Spring-Boot+AOP+统计单次请求方法的执行次数和耗时情况
热门推荐
ruiguang21的博客
01-23 1万+
package com.yanshu.aspect; import java.util.*; import org.aspectj.lang.JoinPoint;   import org.aspectj.lang.ProceedingJoinPoint;   import org.aspectj.lang.annotation.AfterReturning;  
log(五)——MDC总结
xxcupid的博客
07-21 6845
1.为什么最开始子线程会得到父线程MDC设置的内容? 创建子线程的时候会调用init(ThreadGroup g, Runnable target, String name,long stackSize)方法，判断如果parent.inheritableThreadLocals不为null就调用createInheritedMap方法把父线程的ThreadLocal里保存的变量都加载到子线程的T
JDK源码系列：ThreadLocalMap内存泄漏“自动回收的触发场景”分析
super_scan的专栏
03-23 578
在前面的文章中老吕分析了ThreadLocal的实现原理，ThreadLocal的内存泄漏，ThreadLocalMap 失效条目清理原理，本文分析下ThreadLocal内存回收的触发时机。一、getEntry(key)触发时机：发生哈希冲突时触发getEntry逻辑如下：1、直接命中，返回Entry结束，此种场景不会触发内存回收（对应key存在且没有hash冲突的场景）2、没有直接命中，通过线...
Java：ThreadLocal解析
qq_46119575的博客
07-05 1872
ThreadLocal 是java中非常重要的内容，本文尽可能的全面介绍了 ThreadLocal内容，包括内存泄漏，key弱引用等问题第一种解释：ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。
一文搞懂 ThreadLocal，是时候反问面试官了
兴趣是最好的老师，勤能补拙
07-04 5150
ThreadLocaL是Java中的一个线程级别的变量，它提供了一种将数据与每个线程关联起来的机制。每个线程都有自己独立的实例，可以在这个实例中存储和获取数据，而不会与其他线程的数据产生冲突。的作用和用途主要有以下几个方面：可以用于保存每个线程所需的私有数据。例如，在多线程环境下，如果有一个对象需要在线程之间共享，但又希望每个线程都拥有它的私有拷贝，则可以使用来存储这个对象。这样，每个线程都可以独立地读取和修改自己的私有拷贝，而互不干扰。可以避免使用线程同步机制（如锁）来保护共享数据，从而提高程序的并发性能
ThreadLocal和线程池
10-17
ThreadLocal和线程池是两个不同的概念，它们之间没有直接的联系。但是，在使用线程池时，如果需要在多个线程之间共享数据，可以使用ThreadLocal来实现每个线程独立地访问自己的数据副本。 例如，在使用线程池处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值