Java线程池实现父子线程上下文传递以及MDC追踪

文章目录

1. 总览
2. 代码实现
- 2.1. 日志配置
- 2.2. ThreadPoolExecutor 父子线程信息不传递
- 2.3. ContextPassThreadPoolExecutor 父子线程信息传递
3. 整体架构

1. 总览

在公司的项目中，为了解决慢接口问题，主线程经常会引入线程池并发调用下游的 RPC，但是我们希望主线程中的信息也能够传递到线程池子线程中。主要包含两类信息：

主线程请求打进来的时候通常都会经过 Interceptor 往 ThreadLocal 中塞入一些通用用户信息，包括用户姓名、用户 ID 等，这些信息需要传递到子线程，供子线程调用
为了实现链路追踪，需要整个调用链中都使用相同的 traceId，因此主线程也需要将这个 traceId 传递给子线程，否则日志里就只会展示主线程的信息

但是 java.util.concurrent 包中的 ThreadPoolExecutor 并不能实现父子线程上下文信息的传递，因此需要自己实现上下文传递线程池，下面文章的篇幅会着重在于 logback 日志配置，上下文传递线程池。

2. 代码实现

2.1. 日志配置

项目整体采用 SpringBoot2, 使用了自带的 logback 日志，我自定义了配置文件

application.yml 配置：

spring:
  profiles:
    active: dev

logging:
  config: classpath:logback-config.xml

server:
  port: 8099

logback-config.xml 配置:

<?xml version="1.0" encoding="UTF-8"?>
        <!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
        <!-- scan:当此属性设置为true时，配置文档如果发生改变，将会被重新加载，默认值为true -->
        <!-- scanPeriod:设置监测配置文档是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。
                                 当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
        <!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration scan="true" scanPeriod="1 seconds">

    <!-- 日志名称，默认从取 spring.application.name -->
    <springProperty name="contextName" source="spring.application.name"/>
    <!-- 运行环境 -->
    <springProperty name="envName" source="spring.profiles.active"/>

    <!-- property：指定变量，name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义后，可以使“${}”来使用变量 -->
    <!-- 日志存放目录，使用项目名，这样在多服务中，可以根据服务名分目录存储日志 -->
    <property name="log.path" value="src/main/resources/log"/>

    <!--0. 日志格式和颜色渲染 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
    <conversionRule conversionWord="wex"
                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <conversionRule conversionWord="wEx"
                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
    <!--
        控制台彩色日志格式
        日志解读：
        %clr([${contextName},${envName:-dev}]){yellow}：输出项目名称和项目使用环境（黄色）
        %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint}：输出日期，格式：yyyy-MM-dd HH:mm:ss.SSS
        %clr(%5p)：输出日志格式。并对齐5位。如果是INFO、WARN这种四个字符的，默认在最左边加入一个空格（info为蓝色，warn为浅红，error为加粗红，debug为黑色）
        %clr(${PID:- }){magenta}：输出PID（品红色）。ps：${PID:- } 这个 ${} 使用方式表示，有PID则显示PID，没有则显示-
        [%15.15t]：输出线程名称。如果记录的线程字符长度小于15(第一个)则用空格在左侧补齐,如果字符长度大于15(第二个),则从开头开始截断多余的字符
        %clr(%-50.50(%logger{50})){cyan}：
            %-50.50()：如果记录的logger字符长度小于50(第一个)则用空格在右侧补齐,如果字符长度大于50(第二个),则从开头开始截断多余的字符
            %logger{50}：输出日志名字 一般采用日志所在类名或者包名做日志名
            {cyan}：输出颜色（青色）
        %msg%n"：日志输出内容+换行（%n）
     -->
    <property name="console.log.pattern"
              value="%clr([${contextName},${envName:-dev}]){yellow} %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(%5p) %clr(${PID:- }){magenta} %clr(---){faint} [%15.15t] %clr(%-50.50(%logger{50})){cyan} : %msg%n"/>
    <!--  文件日志格式。ps:日志文件中没有设置颜色,否则颜色部分会有ESC[0:39em等乱码- -->
    <property name="log.pattern"
              value="[${contextName},${envName:-dev}] %d{yyyy-MM-dd HH:mm:ss.SSS} %5p ${PID:- } --- [%15.15t] %-50.50(%logger{50}) : %msg%n"/>
    <property name="trace.pattern"
              value="[%t] trace_id: [%X{TRACE_ID}] -%m%n"/>

    <!--1. 输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <Pattern>${trace.pattern}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--2. 输出到文档-->
    <!-- 2.0 输入全部level日志 ，视项目需求而定，可删除-->
    <appender name="allLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 当前日志输出路径、文件名 -->
        <file>${log.path}/all.log</file>
        <!--日志输出格式-->
        <encoder>
            <pattern>${console.log.pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!--历史日志归档策略-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 历史日志： 归档文件名，分了目录的话，要加 aux 不然日志文件不能按时生成，%i表示序号，在这里不能少，因为如果当一个文件到了指定大小后，那就要按照%i来生成顺序下的另一个文件 -->
            <!--保存日志策略 根据 %d{yyyy-MM-dd} 进行保存 %d{yyyy-MM-dd}:按天进行保存 %d{yyyy-MM-dd HH}:按小时进行保存-->
            <fileNamePattern>${log.path}/%d{yyyy-MM, aux}/all/all.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <!--单个文件的最大大小-->
            <maxFileSize>100MB</maxFileSize>
            <!-- <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"> -->
            <!--     <maxFileSize>100MB</maxFileSize> -->
            <!-- </timeBasedFileNamingAndTriggeringPolicy> -->
            <!--日志文件保留天数-->
            <maxHistory>7</maxHistory>
            <!--用来指定日志文件的上限大小，到了这个值，就会删除旧的日志-->
            <totalSizeCap>10GB</totalSizeCap>
        </rollingPolicy>
    </appender>

    <!-- 2.1 level为 DEBUG 日志，时间滚动输出  -->
    <appender name="debugLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 当前日志输出路径、文件名 -->
        <file>${log.path}/debug.log</file>
        <!--日志输出格式-->
        <encoder>
            <pattern>${log.pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>

        <!--历史日志归档策略-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 历史日志： 归档文件名，分了目录的话，要加 aux 不然日志文件不能按时生成，%i表示序号，在这里不能少，因为如果当一个文件到了指定大小后，那就要按照%i来生成顺序下的另一个文件 -->
            <fileNamePattern>${log.path}/%d{yyyy-MM, aux}/debug/debug.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <!--单个文件的最大大小-->
            <maxFileSize>100MB</maxFileSize>
            <!--日志文件保留天数-->
            <maxHistory>7</maxHistory>
            <!--用来指定日志文件的上限大小，到了这个值，就会删除旧的日志-->
            <totalSizeCap>10GB</totalSizeCap>
        </rollingPolicy>

        <!-- 此日志文档只记录debug级别的  level过滤器-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.2 level为 INFO 日志，时间滚动输出  -->
    <appender name="infoLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 当前日志输出路径、文件名 -->
        <file>${log.path}/info.log</file>
        <!--日志输出格式-->
        <encoder>
            <pattern>${console.log.pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>

        <!--历史日志归档策略-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 历史日志： 归档文件名，分了目录的话，要加 aux 不然日志文件不能按时生成，%i表示序号，在这里不能少，因为如果当一个文件到了指定大小后，那就要按照%i来生成顺序下的另一个文件 -->
            <fileNamePattern>${log.path}/%d{yyyy-MM, aux}/info/info.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <!--单个文件的最大大小-->
            <maxFileSize>100MB</maxFileSize>
            <!--日志文件保留天数-->
            <maxHistory>7</maxHistory>
            <!--用来指定日志文件的上限大小，到了这个值，就会删除旧的日志-->
            <totalSizeCap>10GB</totalSizeCap>
        </rollingPolicy>

        <!-- 此日志文档只记录info级别的  level过滤器-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.3 level为 WARN 日志，时间滚动输出  -->
    <appender name="warnLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 当前日志输出路径、文件名 -->
        <file>${log.path}/warn.log</file>
        <!--日志输出格式-->
        <encoder>
            <pattern>${log.pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>

        <!--历史日志归档策略-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 历史日志： 归档文件名，分了目录的话，要加 aux 不然日志文件不能按时生成，%i表示序号，在这里不能少，因为如果当一个文件到了指定大小后，那就要按照%i来生成顺序下的另一个文件 -->
            <fileNamePattern>${log.path}/%d{yyyy-MM, aux}/warn/warn.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <!--单个文件的最大大小-->
            <maxFileSize>100MB</maxFileSize>
            <!--日志文件保留天数-->
            <maxHistory>7</maxHistory>
            <!--用来指定日志文件的上限大小，到了这个值，就会删除旧的日志-->
            <totalSizeCap>10GB</totalSizeCap>
        </rollingPolicy>

        <!-- 此日志文档只记录warn级别的  level过滤器-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.4 level为 ERROR 日志，时间滚动输出  -->
    <appender name="errorLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 当前日志输出路径、文件名 -->
        <file>${log.path}/error.log</file>
        <!--日志输出格式-->
        <encoder>
            <pattern>${log.pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>

        <!--历史日志归档策略-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 历史日志： 归档文件名，分了目录的话，要加 aux 不然日志文件不能按时生成，%i表示序号，在这里不能少，因为如果当一个文件到了指定大小后，那就要按照%i来生成顺序下的另一个文件 -->
            <fileNamePattern>${log.path}/%d{yyyy-MM, aux}/error/error.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <!--单个文件的最大大小-->
            <maxFileSize>100MB</maxFileSize>
            <!--日志文件保留天数-->
            <maxHistory>7</maxHistory>
            <!--用来指定日志文件的上限大小，到了这个值，就会删除旧的日志-->
            <totalSizeCap>10GB</totalSizeCap>
        </rollingPolicy>

        <!-- 此日志文档只记录error级别的  level过滤器-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>error</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 文件 异步日志(async) -->
    <appender name="asyncAppLog" class="ch.qos.logback.classic.AsyncAppender"
              immediateFlush="false" neverBlock="true">
        <!-- 0：不丢失日志.20：如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
        <discardingThreshold>0</discardingThreshold>
        <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
        <queueSize>1024</queueSize>
        <!-- 队列满了不阻塞调用者-->
        <neverBlock>true</neverBlock>
        <!-- 添加附加的appender,最多只能添加一个 -->
        <appender-ref ref="allLog"/>
    </appender>

    <!--
        由于队列中还会有没有打印的日志内容，因此需要等待一段时间，等待队列处理完毕。
        单位是ms。如果队列较大，队列内容较多，可以将此值设置的较大。如果超过此时间队列中的日志还没有处理完毕，则队列中的日志将抛弃
     -->
    <shutdownHook class="ch.qos.logback.core.hook.DelayingShutdownHook">
        <delay>2000</delay>
    </shutdownHook>

    <!--
        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、 以及指定<appender>。
        <logger>仅有一个name属性， 一个可选的level和一个可选的addtivity属性。
        name:用来指定受此logger约束的某一个包或者具体的某一个类。
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
              还有一个特殊值INHERITED或者同义词NULL，代表强制执行上级的级别。
              如果未设置此属性，那么当前logger将会继承上级的级别。
        addtivity:是否向上级logger传递打印信息。默认是true。
        <logger name="org.springframework.web" level="info"/>
        <logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>
    -->

    <!--
        root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
        不能设置为INHERITED或者同义词NULL。默认是DEBUG
        可以包含零个或多个元素，标识这个appender将会添加到这个logger。
    -->

    <!-- 4. 最终的策略 可根据环境分别制定不同的日志策略。注意，这里的 allLog 没在root中声明，在上面的 asyncAppLog 声明（异步处理）-->
    <!-- 4.1 开发环境:打印控制台，可把其他打印到文件的<appender-ref>注释 -->
    <springProfile name="dev">
        <root level="info">
            <appender-ref ref="CONSOLE"/>
            <appender-ref ref="debugLog"/>
            <appender-ref ref="infoLog"/>
            <appender-ref ref="warnLog"/>
            <appender-ref ref="errorLog"/>
            <appender-ref ref="asyncAppLog"/>
        </root>
    </springProfile>

    <!-- 4.2 生产环境:输出到文档
    <springProfile name="pro">
        <root level="info">
            <appender-ref ref="CONSOLE"/>
            <appender-ref ref="debugLog"/>
            <appender-ref ref="infoLog"/>
            <appender-ref ref="warnLog"/>
            <appender-ref ref="errorLog"/>
            <appender-ref ref="asyncAppLog"/>
        </root>
    </springProfile> -->

</configuration>

2.2. ThreadPoolExecutor 父子线程信息不传递

配置 ThreadPoolExecutor bean

package com.jxz;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2024/9/17
 */
@Configuration
public class ThreadPoolConfig {
    @Bean
    public ThreadPoolExecutor threadPoolExecutor() {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 1L, TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(1), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        return threadPoolExecutor;
    }
}

SpringBoot 启动类：

package com.jxz;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2024/9/16
 */
@SpringBootApplication
@Slf4j
public class SpringBootTest implements CommandLineRunner {

    @Autowired
    ThreadPoolExecutor threadPoolExecutor;

    public static void main(String[] args) {
        SpringApplication.run(SpringBootTest.class, args);
    }

    @Override
    public void run(String... args) {
        // 主线程信息 uuid 和 userName 放入 MDC 和 ThreadLocal
        String uuid = UUID.randomUUID().toString();
        String userName = "jxz";
        ThreadLocalUtils.put(ThreadLocalUtils.TRACE_ID, uuid);
        ThreadLocalUtils.put(ThreadLocalUtils.USER_NAME, userName);
        MDC.put(ThreadLocalUtils.TRACE_ID, uuid);
        log.info("main 线程打印...");
        threadPoolExecutor.submit(() -> {
            log.info("子线程 begin...");
            // 打印子线程的 MDC 和 ThreadLocal，继承主线程需要上下文线程池
            Map<String, String> innerMap = ThreadLocalUtils.get();
            log.info("USER_NAME = {}", innerMap.get(ThreadLocalUtils.USER_NAME));
            log.info("子线程 end...");
        });
    }
}

其中用到的 MDC 是 org.slf4j 定义的一种规范，能够让调用方往 log 输出中放入自定义的变量值，MDC.put(key, value)，key 就是 logback-config.xml 定义的占位符，我这里是想打印 traceId，对应的日志配置如下，value 就是占位符中的值

MDC 的源码实现就是 ThreadLocal，所以可以看到我的代码中显示使用 ThreadLocal 的地方，MDC 也会成对出现。

<property name="trace.pattern"
          value="[%t] trace_id: [%X{TRACE_ID}] -%m%n"/>

其中 ThreadLocalUtils 是 ThreadLocal 操作工具类

package com.jxz;

import java.util.HashMap;
import java.util.Map;

/**
 * ThreadLocal 操作工具类
 *
 * @Author jiangxuzhao
 * @Description
 * @Date 2024/9/19
 */
public class ThreadLocalUtils {

    public static final String TRACE_ID = "TRACE_ID";

    public static final String USER_NAME = "USER_NAME";

    private static ThreadLocal<Map<String, String>> threadLocal
            = ThreadLocal.withInitial(() -> new HashMap<>());

    public static Map<String, String> get() {
        return threadLocal.get();
    }

    public static void put(String key, String value) {
        Map<String, String> map = threadLocal.get();
        map.put(key, value);
    }

    public static void clear() {
        threadLocal.remove();
    }
}

启动输出为：

只在主线程中打印了 traceId, 线程池中的子线程没有传递进来，并且 ThreadLocal 变量 USER_NAME 也没有传递进来，这是符合预期的，因为本质上 ThreadLocal 就是实现的线程隔离，想实现线程传递只能自己手动塞入。

[main] trace_id: [47e1e776-a15c-4d80-a950-729b61e6465b] -main 线程打印...
[pool-2-thread-1] trace_id: [] -子线程 begin...
[pool-2-thread-1] trace_id: [] -USER_NAME = null
[pool-2-thread-1] trace_id: [] -子线程 end...

2.3. ContextPassThreadPoolExecutor 父子线程信息传递

实现信息传递线程池 ContextPassThreadPoolExecutor，其实就是拓展 ThreadPoolTaskExecutor，配置了一个装饰器。该装饰器会将投递进线程池的 Runnable 任务进行包装，主线程调用 taskDecorator.decorate 方法，先拿出主线程的 ThreadLocal 变量暂存起来，当子线程 Runnable 任务执行的时候，就会将前面主线程取出的变量放入自己的 ThreadLocal 中。

package com.jxz;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.Map;

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2024/9/17
 */
@Slf4j
public class ContextPassThreadPoolExecutor extends ThreadPoolTaskExecutor {

    public ContextPassThreadPoolExecutor() {
        this.setTaskDecorator((runnable) -> {
            // 主线程中取出 ThreadLocal 信息
            Map<String, String> mainThreadLocal = ThreadLocalUtils.get();
            String uuid = mainThreadLocal.get(ThreadLocalUtils.TRACE_ID);
            String userName = mainThreadLocal.get(ThreadLocalUtils.USER_NAME);
            return () -> {
                try {
                    // 子线程中处理传入主线程的上下文信息
                    MDC.put(ThreadLocalUtils.TRACE_ID, uuid);
                    log.info("线程池装饰器 begin...");
                    Map<String, String> subThreadLocal = ThreadLocalUtils.get();
                    subThreadLocal.put(ThreadLocalUtils.USER_NAME, userName);
                    runnable.run();
                    log.info("线程池装饰器 end...");
                } catch (Exception e) {
                    log.error("Exception occurs", e);
                } finally {
                    MDC.remove(ThreadLocalUtils.TRACE_ID);
                    ThreadLocalUtils.clear();
                }
            };
        });
    }
}

配置 Bean

package com.jxz;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2024/9/17
 */
@Configuration
public class ThreadPoolConfig {
    @Bean
    public ContextPassThreadPoolExecutor contextPassThreadPoolExecutor() {
        ContextPassThreadPoolExecutor contextPassThreadPoolExecutor = new ContextPassThreadPoolExecutor();
        contextPassThreadPoolExecutor.setCorePoolSize(1);
        contextPassThreadPoolExecutor.setMaxPoolSize(1);
        contextPassThreadPoolExecutor.setThreadFactory(Executors.defaultThreadFactory());
        contextPassThreadPoolExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        contextPassThreadPoolExecutor.initialize();
        return contextPassThreadPoolExecutor;
    }
}

SpringBoot 启动类:

直接引用上下文线程池 ContextPassThreadPoolExecutor

package com.jxz;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Map;
import java.util.UUID;

/**
 * @Author jiangxuzhao
 * @Description
 * @Date 2024/9/16
 */
@SpringBootApplication
@Slf4j
public class SpringBootTest implements CommandLineRunner {

    @Autowired
    ContextPassThreadPoolExecutor contextPassThreadPoolExecutor;
    
    public static void main(String[] args) {
        SpringApplication.run(SpringBootTest.class, args);
    }

    @Override
    public void run(String... args) {
        // 主线程信息 uuid 和 userName 放入 MDC 和 ThreadLocal
        String uuid = UUID.randomUUID().toString();
        String userName = "jxz";
        ThreadLocalUtils.put(ThreadLocalUtils.TRACE_ID, uuid);
        ThreadLocalUtils.put(ThreadLocalUtils.USER_NAME, userName);
        MDC.put(ThreadLocalUtils.TRACE_ID, uuid);
        log.info("main 线程打印...");
        contextPassThreadPoolExecutor.submit(() -> {
            log.info("子线程 begin...");
            // 打印子线程的 MDC 和 ThreadLocal，继承主线程需要上下文线程池
            Map<String, String> innerMap = ThreadLocalUtils.get();
            log.info("USER_NAME = {}", innerMap.get(ThreadLocalUtils.USER_NAME));
            log.info("子线程 end...");
        });
    }

输出:

可以看出，trace_id 从父线程传递到了子线程，并且 ThreadLocal 变量 USER_NAME 也被传递进来了。

[main] trace_id: [cf75bee3-1d56-4e99-a96e-96cd71a84c78] -main 线程打印...
[pool-2-thread-1] trace_id: [cf75bee3-1d56-4e99-a96e-96cd71a84c78] -线程池装饰器 begin...
[pool-2-thread-1] trace_id: [cf75bee3-1d56-4e99-a96e-96cd71a84c78] -子线程 begin...
[pool-2-thread-1] trace_id: [cf75bee3-1d56-4e99-a96e-96cd71a84c78] -USER_NAME = jxz
[pool-2-thread-1] trace_id: [cf75bee3-1d56-4e99-a96e-96cd71a84c78] -子线程 end...
[pool-2-thread-1] trace_id: [cf75bee3-1d56-4e99-a96e-96cd71a84c78] -线程池装饰器 end...