CompletableFuture场景下MDC日志上下文传递失效问题求助

这个问题我之前也碰到过——CompletableFuture默认使用ForkJoinPool.commonPool，线程池里的线程是复用的，而MDC是基于ThreadLocal实现的，主线程的MDC上下文（比如你说的sessionID）不会自动传递到异步任务的线程中，导致日志缺失关键信息。下面给你几个实用的解决办法：

1. 手动捕获并传递MDC上下文（快速解决） #

在提交异步任务前，先把主线程的MDC上下文拷贝出来，在异步任务执行时设置进去，执行完成后记得恢复线程原本的上下文（避免线程复用导致的上下文污染）：

// 拷贝当前主线程的MDC上下文
Map<String, String> mainThreadMdc = MDC.getCopyOfContextMap();

CompletableFuture.runAsync(() -> {
    // 保存异步线程原本的MDC上下文
    Map<String, String> originalThreadMdc = MDC.getCopyOfContextMap();
    try {
        // 将主线程的MDC上下文设置到当前异步线程
        if (mainThreadMdc != null) {
            MDC.setContextMap(mainThreadMdc);
        }
        // 执行你的业务逻辑
        getAcountDetails(user);
    } finally {
        // 恢复异步线程原本的上下文，避免线程复用污染
        if (originalThreadMdc != null) {
            MDC.setContextMap(originalThreadMdc);
        } else {
            MDC.clear();
        }
    }
});

2. 封装通用工具类（避免重复代码） #

如果项目里很多地方用到CompletableFuture，手动写上面的逻辑太繁琐，可以封装一个工具类，把MDC传递的逻辑抽象成通用方法：

public class MdcAsyncUtil {
    // 包装Runnable，自动传递MDC上下文
    public static Runnable wrapWithMdc(Runnable runnable) {
        Map<String, String> parentMdc = MDC.getCopyOfContextMap();
        return () -> {
            Map<String, String> originalMdc = MDC.getCopyOfContextMap();
            try {
                if (parentMdc != null) {
                    MDC.setContextMap(parentMdc);
                }
                runnable.run();
            } finally {
                // 恢复原上下文
                if (originalMdc != null) {
                    MDC.setContextMap(originalMdc);
                } else {
                    MDC.clear();
                }
            }
        };
    }

    // 包装Supplier，适配有返回值的场景
    public static <T> Supplier<T> wrapWithMdc(Supplier<T> supplier) {
        Map<String, String> parentMdc = MDC.getCopyOfContextMap();
        return () -> {
            Map<String, String> originalMdc = MDC.getCopyOfContextMap();
            try {
                if (parentMdc != null) {
                    MDC.setContextMap(parentMdc);
                }
                return supplier.get();
            } finally {
                if (originalMdc != null) {
                    MDC.setContextMap(originalMdc);
                } else {
                    MDC.clear();
                }
            }
        };
    }
}

使用的时候就非常简洁了：

// 无返回值场景
CompletableFuture.runAsync(MdcAsyncUtil.wrapWithMdc(() -> getAcountDetails(user)));

// 有返回值场景
CompletableFuture.supplyAsync(MdcAsyncUtil.wrapWithMdc(() -> fetchUserInfo(user)));

3. 自定义ForkJoinPool（全局自动传递） #

如果想让所有CompletableFuture任务都自动传递MDC，可以自定义一个支持MDC传递的ForkJoinPool，重写任务提交方法，自动包装任务：

public class MdcForkJoinPool extends ForkJoinPool {
    public MdcForkJoinPool() {
        super();
    }

    public MdcForkJoinPool(int parallelism) {
        super(parallelism);
    }

    @Override
    public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task) {
        return super.submit(wrapForkJoinTask(task));
    }

    @Override
    public void execute(Runnable task) {
        super.execute(MdcAsyncUtil.wrapWithMdc(task));
    }

    private <T> ForkJoinTask<T> wrapForkJoinTask(ForkJoinTask<T> task) {
        Map<String, String> parentMdc = MDC.getCopyOfContextMap();
        return new ForkJoinTask<T>() {
            private static final long serialVersionUID = 1L;

            @Override
            public T getRawResult() {
                return task.getRawResult();
            }

            @Override
            protected void setRawResult(T value) {
                task.setRawResult(value);
            }

            @Override
            protected boolean exec() {
                Map<String, String> originalMdc = MDC.getCopyOfContextMap();
                try {
                    if (parentMdc != null) {
                        MDC.setContextMap(parentMdc);
                    }
                    return task.exec();
                } finally {
                    if (originalMdc != null) {
                        MDC.setContextMap(originalMdc);
                    } else {
                        MDC.clear();
                    }
                }
            }
        };
    }
}

然后在使用CompletableFuture时指定这个自定义池：

// 初始化自定义池（可以全局单例）
MdcForkJoinPool mdcPool = new MdcForkJoinPool(Runtime.getRuntime().availableProcessors());

// 使用自定义池执行异步任务
CompletableFuture.runAsync(() -> getAcountDetails(user), mdcPool);

为什么TaskExecutor的方案没用？ #

你提到的TaskExecutor传递MDC的方案，大多是针对Spring的@Async注解场景，这类场景用的是Spring管理的TaskExecutor线程池；而CompletableFuture默认用的是JDK自带的ForkJoinPool，两者不是同一个线程池体系，所以那套方案不适用。

内容的提问来源于stack exchange，提问作者Mayur