深入理解与解决异步环境中SLF4J MDC丢失问题

import org.slf4j.MDC;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ManualMDCPropagation {

    private static final Logger log = LoggerFactory.getLogger(ManualMDCPropagation.class);
    private static final ExecutorService executor = Executors.newFixedThreadPool(2);
    private static final String TRACE_ID_KEY = "traceId";

    public static void main(String[] args) throws InterruptedException {
        // 1. 在主线程设置MDC
        MDC.put(TRACE_ID_KEY, "main-request-123");
        log.info("主线程日志：开始处理请求");

        // 2. 获取MDC副本
        Map<String, String> contextMap = MDC.getCopyOfContextMap();

        // 3. 提交异步任务
        CompletableFuture.runAsync(() -> {
            // 4. 在异步线程中恢复MDC
            if (contextMap != null) {
                MDC.setContextMap(contextMap);
            }
            try {
                log.info("异步任务日志：执行中...");
                // 模拟耗时操作
                Thread.sleep(100);
                log.info("异步任务日志：完成");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 5. 清除MDC，防止泄露
                MDC.clear();
            }
        }, executor);

        // 主线程继续执行，并清除MDC
        Thread.sleep(200); // 确保异步任务有时间执行
        log.info("主线程日志：请求处理完成");
        MDC.clear(); // 清除主线程的MDC

        executor.shutdown();
    }
}

import org.slf4j.MDC;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.TtlRunnable;
import com.alibaba.ttl.threadpool.TtlExecutors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TtlMDCPropagation {

    private static final Logger log = LoggerFactory.getLogger(TtlMDCPropagation.class);
    private static final String TRACE_ID_KEY = "traceId";

    public static void main(String[] args) throws InterruptedException {
        // 1. 包装线程池，使其支持TransmittableThreadLocal
        ExecutorService rawExecutor = Executors.newFixedThreadPool(2);
        ExecutorService ttlExecutor = TtlExecutors.get "> // 确保TTL上下文能被传递

        // 2. 在主线程设置MDC
        MDC.put(TRACE_ID_KEY, "main-request-456");
        log.info("主线程日志：开始处理请求");

        // 3. 提交异步任务
        ttlExecutor.submit(() -> {
            try {
                log.info("TTL异步任务日志：执行中...");
                Thread.sleep(100);
                log.info("TTL异步任务日志：完成");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                MDC.clear(); // 任务结束时清除MDC
            }
        });

        // 主线程继续执行，并清除MDC
        Thread.sleep(200);
        log.info("主线程日志：请求处理完成");
        MDC.clear();

        ttlExecutor.shutdown();
        ttlExecutor.awaitTermination(1, TimeUnit.SECONDS);
    }
}

// ====== 决策者代码 (Workflow Decider) ======
public class MyWorkflowDecider implements Workflow {

    private static final Logger log = LoggerFactory.getLogger(MyWorkflowDecider.class);
    private static final String TRACE_ID_KEY = "traceId";

    @Override
    public void myWorkflowMethod(String initialInput) {
        // 1. 工作流开始时设置MDC（如果这是入口点）
        String workflowId = "workflow-" + System.currentTimeMillis(); // 假设从某种方式获取
        MDC.put(TRACE_ID_KEY, workflowId);
        log.info("决策者日志：开始工作流，输入: {}", initialInput);

        // 2. 调度第一个活动
        MyActivityInput activity1Input = new MyActivityInput();
        activity1Input.setData("data for activity 1");
        activity1Input.setTraceId(MDC.get(TRACE_ID_KEY)); // 从MDC获取并传递
        activities.activity1(activity1Input); // 假设activities是一个SWF活动客户端

        // ... 更多决策逻辑 ...

        MDC.clear(); // 清除MDC
    }
}

// ====== 活动工作者代码 (Activity Worker) ======
public class MyActivityWorker implements MyActivity {

    private static final Logger log = LoggerFactory.getLogger(MyActivityWorker.class);
    private static final String TRACE_ID_KEY = "traceId";

    @Override
    public String activity1(MyActivityInput input) {
        // 1. 活动开始时，从输入中提取traceId并设置到MDC
        String traceId = input.getTraceId();
        if (traceId != null) {
            MDC.put(TRACE_ID_KEY, traceId);
        }

        try {
            log.info("活动工作者日志：执行Activity1，接收数据: {}", input.getData());
            // 业务逻辑
            String result = "Processed: " + input.getData();
            log.info("活动工作者日志：Activity1 完成，结果: {}", result);
            return result;
        } finally {
            // 2. 清除MDC
            MDC.clear();
        }
    }
}

// ====== 活动输入对象 ======
public class MyActivityInput {
    private String data;
    private String traceId; // 用于MDC传播的字段

    // Getters and Setters
    public String getData() { return data; }
    public void setData(String data) { this.data = data; }
    public String getTraceId() { return traceId; }
    public void setTraceId(String traceId) { this.traceId = traceId; }
}