java多线程使用mdc追踪日志方式

更新时间：2021年09月23日 09:48:14 作者：致林

这篇文章主要介绍了java多线程使用mdc追踪日志方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

多线程使用mdc追踪日志

背景

多线程情况下，子线程的sl4j打印日志缺少traceId等信息，导致定位问题不方便

解决方案

打印日志时添加用户ID、trackId等信息，缺点是每个日志都要手动添加
使用mdc直接拷贝父线程值

实现

// 新建线程时：
Map<String, String> mdcContextMap = MDC.getCopyOfContextMap()
// 子线程运行时：
if(null != mdcContextMap){
    MDC.setContextMap(mdcContextMap);
}
// 销毁线程时
MDC.clear();

参考

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);
                    }
                }
            }
        };
    }
}

多线程日志追踪

主要目的是记录工作中的一些编程思想和细节，以便后来查阅。

1.问题描述

由于项目中设计高并发内容，涉及到一个线程创建多个子线程的情况。那么，如何跟踪日志，识别子线程是由哪个主线程创建的，属于哪个request请求。

例如，在现有项目中，一个设备信息上传的请求（包括基本数据和异常数据两种数据），然后主线程创建两个子线程，来处理基本数据和异常数据。

简化代码如下：

public class mainApp {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                //接收到一个request
                System.out.println("[Thread-"+ Thread.currentThread().getId() +"]开始发起请求");
                String[] data = {"异常数据","基本数据"};
                //创建子线程1，处理异常数据
                MThread mThread1 = new MThread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("[Thread-"+ Thread.currentThread().getId() +"]处理了" + data[0]);
                    }
                });
                创建子线程2，处理普通数据
                MThread mThread2 = new MThread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("[Thread-"+ Thread.currentThread().getId() +"]处理了"  + data[1]);
                    }
                });
                new Thread(mThread1).start();
                new Thread(mThread2).start(); 
            }
        });
        t.start();
    }
}
 
class MThread implements Runnable { 
    private Runnable r; 
    public MThread(Runnable r) {
        this.r = r;
    }
 
    @Override
    public void run() {
        r.run();
    }
}

运行结果如下：

一个请求有三个线程，如果有多个请求，运行结果如下：

从日志中无法看出他们之间的所属关系（判断不出来他们是否是处理同一个request请求的）。如果某一个线程出现问题，我们也很难快速定位是哪个请求的处理结果。

2. 代理实现日志追踪

因此，我们使用MDC来在日志中增加traceId（同一个请求的多个线程拥有同一个traceId）。

思路如下：

1. 在request进来的时候，利用AOP为每个request创建一个traceId（保证每个request的traceId不同，同一个request的traceId相同）

2. 创建子线程的时候，将traceId通过动态代理的方式，传递到子线程中

public class mainApp {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                //AOP 生成一个traceId
                MDC.put("traceId", UUID.randomUUID().toString().replace("-", ""));
                //接收到一个request
                System.out.println("[Thread-"+ Thread.currentThread().getId() +"]traceId["+ MDC.get("traceId") +"]开始发起请求");
                String[] data = {"异常数据","基本数据"};
 
                MThread mThread1 = new MThread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("[Thread-"+ Thread.currentThread().getId() +"]traceId["+ MDC.get("traceId") +"]处理了" + data[0]);
                    }
                }, MDC.getCopyOfContextMap());
                MThread mThread2 = new MThread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("[Thread-"+ Thread.currentThread().getId() +"]traceId["+ MDC.get("traceId") +"]处理了"  + data[1]);
                    }
                }, MDC.getCopyOfContextMap());
                new Thread(mThread1).start();
                new Thread(mThread2).start(); 
            }
        };
        new Thread(runnable).start();
        new Thread(runnable).start();
    }
}
 
class MThread implements Runnable { 
    private Runnable r; 
    public MThread(Runnable r, Map<String, String> parentThreadMap) {
        LogProxy logProxy = new LogProxy(r, parentThreadMap);
        Runnable rProxy = (Runnable) Proxy.newProxyInstance(r.getClass().getClassLoader(), r.getClass().getInterfaces(), logProxy);
        this.r = rProxy;
    }
 
    @Override
    public void run() {
        r.run();
    }
}
 
//日志代理
class LogProxy implements InvocationHandler {
    private Runnable r;
    private  Map<String, String> parentThreadMap;
    public LogProxy(Runnable r, Map<String, String> parentThreadMap) {
        this.r = r;
        this.parentThreadMap = parentThreadMap;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("run")) {
            MDC.setContextMap(parentThreadMap);
        }
        return method.invoke(r, args);
    }
}

运行结果如下：

两个请求，同一个请求的traceId相同，不同请求的traceId不同。完美实现多线程的日志追踪。

实际WEB项目中，只需要在logback日志配置文件中，

logging.pattern.console参数增[%X{traceId}]即可在LOGGER日志中打印traceId的信息。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

springboot集成mybatis-plus全过程
本文详细介绍了如何在SpringBoot环境下集成MyBatis-Plus,包括配置maven依赖、application.yaml文件、创建数据库和Java实体类、Mapper层、Service层和Controller层的设置,同时,还涵盖了时间自动填充、分页查询、多对一和一对多的数据库映射关系设置
2024-09-09
浅谈web服务器项目中request请求和response的相关响应处理
这篇文章主要介绍了浅谈web服务器项目中request请求和response的相关响应处理，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-07-07
Java多线程实现Runnable方式
这篇文章主要为大家详细介绍了Java多线程如何实现Runnable方式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2018-03-03
解决SpringBoot连接SqlServer出现的问题
在尝试通过SSL与SQL Server建立安全连接时,如果遇到“PKIX path building failed”错误,可能是因为未能正确配置或信任服务器证书,当"Encrypt"属性设置为"true"且"trustServerCertificate"属性设置为"false"时,要求驱动程序使用安全套接字层(SSL)加密与SQL Server建立连接
2024-10-10
Java的动态代理模式之Cglib代理详解
这篇文章主要介绍了Java的动态代理模式之Cglib代理详解,Cglib代理也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将Cglib代理归属到动态代理,需要的朋友可以参考下
2023-11-11
springboot简单集成Security配置的教程
这篇文章主要介绍了springboot简单集成Security配置的教程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2025-03-03
Java 设计模式中的命令模式详情
这篇文章主要介绍了Java 设计模式中的命令模式详情，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的朋友可以参考一下
2022-07-07
servlet3新特性_动力节点Java学院整理
这篇文章主要为大家详细介绍了servlet3新特性的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-07-07
java项目启动失败的问题及解决
这篇文章主要介绍了java项目启动失败的问题及解决方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-06-06
Java使用迭代器Iterator遍历集合
Iterator对象称为迭代器（设计模式的一种），主要用于遍历 Collection 集合中的元素。本文就来和大家详细聊聊Java如何使用迭代器Iterator实现遍历集合，感兴趣的可以跟随小编一起学习一下
2022-12-12