如何在线程池中使用MDC？ [英] How to use MDC with thread pools?

问题描述

在我们的软件中，我们广泛使用MDC来跟踪会话ID和Web请求的用户名等内容。这在原始线程中运行时工作正常。但是，有很多事情需要在后台处理。为此我们使用 java.concurrent.ThreadPoolExecutor 和 java.util.Timer 类以及一些自动异步异步执行服务。所有这些服务都管理自己的线程池。

In our software we extensively use MDC to track things like session IDs and user names for web requests. This works fine while running in the original thread. However, there's a lot of things that need to be processed in the background. For that we use the java.concurrent.ThreadPoolExecutor and java.util.Timer classes along with some self-rolled async execution services. All these services manage their own thread pool.

这是 Logback手册必须说明在这样的环境中使用MDC：

This is what Logback's manual has to say about using MDC in such an environment:

映射的诊断上下文的副本并不总是由启动线程的工作线程继承。当java.util.concurrent.Executors用于线程管理时就是这种情况。例如，newCachedThreadPool方法创建一个ThreadPoolExecutor，就像其他线程池代码一样，它有复杂的线程创建逻辑。

A copy of the mapped diagnostic context can not always be inherited by worker threads from the initiating thread. This is the case when java.util.concurrent.Executors is used for thread management. For instance, newCachedThreadPool method creates a ThreadPoolExecutor and like other thread pooling code, it has intricate thread creation logic.

在这种情况下，建议使用MDC.getCopyOfContextMap（）在向执行程序提交任务之前，在原始（主）线程上调用。当任务运行时，作为第一个操作，它应该调用MDC.setContextMapValues（）以将原始MDC值的存储副本与新的Executor托管线程相关联。

In such cases, it is recommended that MDC.getCopyOfContextMap() is invoked on the original (master) thread before submitting a task to the executor. When the task runs, as its first action, it should invoke MDC.setContextMapValues() to associate the stored copy of the original MDC values with the new Executor managed thread.

这样会很好，但是很容易忘记添加这些调用，并且没有简单的方法来识别问题，直到为时已晚。 Log4j的唯一标志是你在日志中丢失了MDC信息，而使用Logback，你得到过时的MDC信息（因为花盆池中的线程从其上运行的第一个任务继承了它的MDC）。两者都是生产系统中的严重问题。

This would be fine, but it is a very easy to forget adding those calls, and there is no easy way to recognize the problem until it is too late. The only sign with Log4j is that you get missing MDC info in the logs, and with Logback you get stale MDC info (since the thread in the tread pool inherits its MDC from the first task that was ran on it). Both are serious problems in a production system.

我不认为我们的情况有任何特殊之处，但我在网上找不到这个问题。显然，这不是很多人碰到的东西，所以必须有办法避免它。我们在这里做错了什么？

I don't see our situation special in any way, yet I could not find much about this problem on the web. Apparently, this is not something that many people bump up against, so there must be a way to avoid it. What are we doing wrong here?

推荐答案

是的，这是我遇到的一个常见问题。有一些解决方法（如手动设置，如上所述），但理想情况下，您需要一个解决方案

Yes, this is a common problem I've run into as well. There are a few workarounds (like manually setting it, as described), but ideally you want a solution that

• 设置MDC一致;


• 避免MDC错误但你不知道的默认错误;和


• 最大限度地减少对线程池使用方式的更改（例如，使用 MyCallable Callable c>无处不在，或类似的丑陋）。

• Sets the MDC consistently;
• Avoids tacit bugs where the MDC is incorrect but you don't know it; and
• Minimizes changes to how you use thread pools (e.g. subclassing Callable with MyCallable everywhere, or similar ugliness).

这是我使用的解决方案，满足这三个需求。代码应该是不言自明的。

Here's a solution that I use that meets these three needs. Code should be self-explanatory.

（作为旁注，可以创建此执行程序并将其提供给Guava的 MoreExecutors.listeningDecorator（），如果
你使用Guava的 ListanableFuture 。）

(As a side note, this executor can be created and fed to Guava's MoreExecutors.listeningDecorator(), if you use Guava's ListanableFuture.)

import org.slf4j.MDC;

import java.util.Map;
import java.util.concurrent.*;

/**
 * A SLF4J MDC-compatible {@link ThreadPoolExecutor}.
 * <p/>
 * In general, MDC is used to store diagnostic information (e.g. a user's session id) in per-thread variables, to facilitate
 * logging. However, although MDC data is passed to thread children, this doesn't work when threads are reused in a
 * thread pool. This is a drop-in replacement for {@link ThreadPoolExecutor} sets MDC data before each task appropriately.
 * <p/>
 * Created by jlevy.
 * Date: 6/14/13
 */
public class MdcThreadPoolExecutor extends ThreadPoolExecutor {

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

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

    /**
     * Pool where task threads take fixed MDC from the thread that creates the pool.
     */
    @SuppressWarnings("unchecked")
    public static MdcThreadPoolExecutor newWithCurrentMdc(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                                                          TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        return new MdcThreadPoolExecutor(MDC.getCopyOfContextMap(), corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue);
    }

    /**
     * Pool where task threads always have a specified, fixed MDC.
     */
    public static MdcThreadPoolExecutor newWithFixedMdc(Map<String, Object> fixedContext, int corePoolSize,
                                                        int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                                        BlockingQueue<Runnable> workQueue) {
        return new MdcThreadPoolExecutor(fixedContext, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    private MdcThreadPoolExecutor(Map<String, Object> fixedContext, int corePoolSize, int maximumPoolSize,
                                  long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        this.fixedContext = fixedContext;
        useFixedContext = (fixedContext != null);
    }

    @SuppressWarnings("unchecked")
    private Map<String, Object> 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(Runnable command) {
        super.execute(wrap(command, getContextForTask()));
    }

    public static Runnable wrap(final Runnable runnable, final Map<String, Object> context) {
        return new Runnable() {
            @Override
            public void run() {
                Map 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);
                    }
                }
            }
        };
    }
}

这篇关于如何在线程池中使用MDC？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！