springboot自定义线程池+mdc异步线程注入traceid

该文介绍了两种在Spring中保持MDC(MappedDiagnosticContext)信息在异步任务执行时跨线程传播的方法。第一种是通过自定义TaskDecorator并配置到ThreadPoolTaskExecutor;第二种是直接扩展ThreadPoolTaskExecutor,重写execute和submit方法来注入MDC上下文。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

两种实现方式:

第一种:自定义任务装饰器,并配置到线程池

定义任务装饰器

package com.dc.smart.core.config.mdc;

import org.slf4j.MDC;
import org.springframework.core.task.TaskDecorator;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author coco
 * @date 2022/11/15
 */
@Component
public class MdcTaskDecorator implements TaskDecorator {

    @Override
    public Runnable decorate(Runnable runnable) {
        // Right now: Web thread context !
        // (Grab the current thread MDC data)
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return () -> {
            try {
                // Right now: @Async thread context !
                // (Restore the Web thread context's MDC data)
                if (contextMap != null) {
                    MDC.setContextMap(contextMap);
                }
                runnable.run();
            } finally {
                MDC.clear();
            }
        };
    }
}

配置线程池

package com.dc.smart.core.config.mdc;

import com.dc.smart.core.config.mdc.MdcTaskDecorator;
import com.dc.smart.core.config.mdc.MdcThreadPoolTaskExecutor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author coco
 * @date 2022/11/15
 */
@Configuration
public class ThreadPoolConfig{
    //参数初始化
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    //核心线程数量大小
    private static final int corePoolSize = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    //线程池最大容纳线程数
    private static final int maxPoolSize = CPU_COUNT * 2 + 1;
    //阻塞队列
    private static final int workQueue = 20;
    //线程空闲后的存活时长
    private static final int keepAliveTime = 30;

    @Autowired
    private MdcTaskDecorator mdcTaskDecorator;

    @Bean("ndAsyncTaskExecutor")
    public ThreadPoolTaskExecutor getAsyncExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        //核心线程数
        threadPoolTaskExecutor.setCorePoolSize(corePoolSize);
        //最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(maxPoolSize);
        //等待队列
        threadPoolTaskExecutor.setQueueCapacity(workQueue);
        //线程前缀
        threadPoolTaskExecutor.setThreadNamePrefix("ndAsyncTask-");
        //线程池维护线程所允许的空闲时间,单位为秒
        threadPoolTaskExecutor.setKeepAliveSeconds(keepAliveTime);
        // 线程池对拒绝任务(无线程可用)的处理策略
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        threadPoolTaskExecutor.setTaskDecorator(mdcTaskDecorator);
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }
}

第二种:重写线程池

package com.dc.smart.core.config.mdc;

import lombok.NonNull;
import org.slf4j.MDC;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * @author coco
 * @date 2022/11/15
 */
public class MdcThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {

     final private boolean useFixedContext;
     final private Map<String, String> fixedContext;

    /**
     * Pool where task threads take MDC from the submitting thread.
     */
    public static MdcThreadPoolTaskExecutor newWithInheritedMdc(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                                                                TimeUnit unit, int queueCapacity) {
        return new MdcThreadPoolTaskExecutor(null, corePoolSize, maximumPoolSize, keepAliveTime, unit, queueCapacity);
    }

    private MdcThreadPoolTaskExecutor(Map<String, String> fixedContext, int corePoolSize, int maximumPoolSize,
                                      long keepAliveTime, TimeUnit unit, int queueCapacity) {
        setCorePoolSize(corePoolSize);
        setMaxPoolSize(maximumPoolSize);
        setKeepAliveSeconds((int) unit.toSeconds(keepAliveTime));
        setQueueCapacity(queueCapacity);
        this.fixedContext = fixedContext;
        useFixedContext = (fixedContext != null);
    }

    private Map<String, String> getContextForTask() {
        return useFixedContext ? fixedContext : MDC.getCopyOfContextMap();
    }

    /**
     * All executions will have MDC injected. {@code ThreadPoolExecutor}'s submission methods ({@code submit()} etc.)
     * all delegate to this.
     */
    @Override
    public void execute(@NonNull Runnable command) {
        super.execute(wrap(command, getContextForTask()));
    }

    @NonNull
    @Override
    public Future<?> submit(@NonNull Runnable task) {
        return super.submit(wrap(task, getContextForTask()));
    }

    @NonNull
    @Override
    public <T> Future<T> submit(@NonNull Callable<T> task) {
        return super.submit(wrap(task, getContextForTask()));
    }

    private static <T> Callable<T> wrap(final Callable<T> task, final Map<String, String> context) {
        return () -> {
            Map<String, String> previous = MDC.getCopyOfContextMap();
            if (context == null) {
                MDC.clear();
            } else {
                MDC.setContextMap(context);
            }
            try {
                return task.call();
            } finally {
                if (previous == null) {
                    MDC.clear();
                } else {
                    MDC.setContextMap(previous);
                }
            }
        };
    }

    private static Runnable wrap(final Runnable runnable, final Map<String, String> context) {
        return () -> {
            Map<String, String> previous = MDC.getCopyOfContextMap();
            if (context == null) {
                MDC.clear();
            } else {
                MDC.setContextMap(context);
            }
            try {
                runnable.run();
            } finally {
                if (previous == null) {
                    MDC.clear();
                } else {
                    MDC.setContextMap(previous);
                }
            }
        };
    }
}
package com.dc.smart.core.config.mdc;

import com.dc.smart.core.config.mdc.MdcTaskDecorator;
import com.dc.smart.core.config.mdc.MdcThreadPoolTaskExecutor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author coco
 * @date 2022/11/15
 */
@Configuration
public class ThreadPoolConfig{
    //参数初始化
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    //核心线程数量大小
    private static final int corePoolSize = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    //线程池最大容纳线程数
    private static final int maxPoolSize = CPU_COUNT * 2 + 1;
    //阻塞队列
    private static final int workQueue = 20;
    //线程空闲后的存活时长
    private static final int keepAliveTime = 30;

    @Autowired
    private MdcTaskDecorator mdcTaskDecorator;

    @Bean("ndAsyncTaskExecutor")
    public ThreadPoolTaskExecutor getAsyncExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = MdcThreadPoolTaskExecutor.newWithInheritedMdc(corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.SECONDS, workQueue);
        //核心线程数
        threadPoolTaskExecutor.setCorePoolSize(corePoolSize);
        //最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(maxPoolSize);
        //等待队列
        threadPoolTaskExecutor.setQueueCapacity(workQueue);
        //线程前缀
        threadPoolTaskExecutor.setThreadNamePrefix("ndAsyncTask-");
        //线程池维护线程所允许的空闲时间,单位为秒
        threadPoolTaskExecutor.setKeepAliveSeconds(keepAliveTime);
        // 线程池对拒绝任务(无线程可用)的处理策略
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        threadPoolTaskExecutor.setTaskDecorator(mdcTaskDecorator);
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }
}

### 解决MDC中TTL导致TraceID丢失的方案 在分布式系统中,当使用多线程或多进程处理请求时,`ThreadLocal` 的局限性可能导致 `MDC` 中存储的上下文信息(如 Trace ID 和 Span ID)无法正确传递到子线程异步任务中。为了防止这种问题的发生,可以采用以下方法: #### 方法一:利用 TransmittableThreadLocal (TTL) 自动传播 MDC 上下文 阿里巴巴开源的 `TransmittableThreadLocal` 提供了一种机制,能够自动将父线程中的 `ThreadLocal` 数据复制并传播给子线程[^3]。具体实现方式如下: 1. **初始化 TTL 支持** 使用 `TtlThreadContextMap` 替代默认的 `ThreadContextMap` 来管理 `MDC` 数据。 ```java import com.alibaba.ttl.TransmittableThreadLocal; import org.apache.logging.log4j.ThreadContext; public class TtlInitializer { static { ThreadContext.setThreadContextMap(new TtlThreadContextMap()); } } ``` 2. **确保 TTL 在线程切换时生效** 当向线程池提交任务时,无需手动拷贝和恢复 `MDC` 上下文,因为 `TTL` 已经接管了这一过程[^4]。 ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TaskExecutor { private final ExecutorService executor = Executors.newCachedThreadPool(); public void executeTask(Runnable task) { // 将任务包装成支持TTL的任务 executor.execute(TransmittableThreadLocal.wrapRunnableWithCurrentContext(task)); } } ``` #### 方法二:显式拷贝与恢复 MDC 上下文 如果不想引入额外依赖库,则可以通过手动操作来保证上下文的一致性。尽管这种方法较为繁琐且侵入性强,但在某些场景下仍然适用[^2]。 1. **保存当前线程MDC 上下文** ```java Map<String, String> contextMap = MDC.getCopyOfContextMap(); ``` 2. **在线程执行前设置上下文** ```java if (contextMap != null) { MDC.setContextMap(contextMap); } ``` 3. **清理资源以防内存泄漏** ```java try { // 执行业务逻辑... } finally { MDC.clear(); } ``` 以上两种方法都可以有效避免因线程切换而导致的 `TraceID` 丢失问题。推荐优先考虑基于 `TTL` 的自动化解决方案,因为它不仅减少了开发人员的工作量,还提高了系统的可靠性和可维护性。 ```java import com.alibaba.ttl.TransmittableThreadLocal; import org.slf4j.MDC; public class DistributedLoggingExample { public void processRequest(String traceId) { MDC.put("traceId", traceId); Runnable task = () -> { System.out.println("Processing with traceId: " + MDC.get("traceId")); }; // 使用TTL包装任务 TransmittableThreadLocal.wrapRunnableWithCurrentContext(task).run(); MDC.remove("traceId"); } } ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值