多线程场景下AspectJ中线程独立LoggingObject实例调用问题

我正在开发一个应用，该应用会在16个线程中并行执行同一处理流程（输入参数为不同的TaskInformation）。我希望创建一个Aspect，从中获取参数与值并存储到Aspect内部创建的对象中。

我的问题是：能否为每个线程独立创建该对象实例，并调用对应实例以存储各线程的正确值？我希望尽可能避免使用ThreadLocal，因为当前未使用Aspect时就依赖它，希望重构后可以摒弃该方案。

补充说明 #

我们有一个Process类，其process方法会在多线程中同时运行。我希望为每个线程填充LoggingObject的信息，并在处理结束后记录整个流程的汇总日志。示例代码如下：

public aspect MyAspect {
    private final LoggingObject log = new LoggingObject();

    pointcut processMethodExecution(TaskInformation taskInfo):
        execution(TaskStatus Processor.process(TaskInformation)) && args(taskInfo);

    after(TaskInformation taskInfo): processMethodExecution(taskInfo) {
        logger.info("Processing task with ID: " + taskInfo.getTaskId());
        log.setID(taskInfo.getTaskId());
    }
}

1. 绑定方法执行周期（推荐） #

直接在环绕通知中为每个process方法调用创建独立的LoggingObject，天然隔离多线程上下文，完全无需依赖ThreadLocal：

public aspect MyAspect {
    pointcut processMethodExecution(TaskInformation taskInfo):
        execution(TaskStatus Processor.process(TaskInformation)) && args(taskInfo);

    @Around("processMethodExecution(taskInfo)")
    public Object trackProcess(ProceedingJoinPoint joinPoint, TaskInformation taskInfo) throws Throwable {
        // 为当前方法调用创建专属LoggingObject
        LoggingObject log = new LoggingObject();
        log.setID(taskInfo.getTaskId());
        
        try {
            // 执行原方法
            TaskStatus result = (TaskStatus) joinPoint.proceed();
            // 填充处理完成后的状态信息
            log.setStatus(result);
            return result;
        } finally {
            // 记录汇总日志
            logger.info("Process completed, summary: " + log.toString());
        }
    }
}

这种方式的核心是每个方法调用对应一个独立的LoggingObject实例，不管线程是否复用，都能保证数据隔离。

2. 基于实例绑定的Aspect实例化 #

如果每个线程使用独立的Processor实例，可以用perthis让Aspect为每个Processor实例创建独立副本：

// 为每个触发切入点的Processor实例创建独立Aspect
public aspect MyAspect perthis(processMethodExecution(TaskInformation)) {
    private LoggingObject log = new LoggingObject();

    pointcut processMethodExecution(TaskInformation taskInfo):
        execution(TaskStatus Processor.process(TaskInformation)) && args(taskInfo);

    before(TaskInformation taskInfo): processMethodExecution(taskInfo) {
        log.setID(taskInfo.getTaskId());
        // 填充其他上下文信息
    }

    after() returning(TaskStatus status): processMethodExecution(TaskInformation) {
        log.setStatus(status);
        logger.info("Process summary: " + log.toString());
    }
}

注意：如果多个线程共享同一个Processor实例，这种方式会导致数据冲突，不适用。

3. 线程级实例管理（备选） #

如果必须绑定线程而非方法调用，可以用ConcurrentHashMap管理线程与LoggingObject的映射，封装掉ThreadLocal的直接依赖：

public aspect MyAspect {
    private final Map<Long, LoggingObject> threadLogMap = new ConcurrentHashMap<>();

    pointcut processMethodExecution(TaskInformation taskInfo):
        execution(TaskStatus Processor.process(TaskInformation)) && args(taskInfo);

    before(TaskInformation taskInfo): processMethodExecution(taskInfo) {
        long threadId = Thread.currentThread().getId();
        // 为当前线程创建或获取LoggingObject
        threadLogMap.putIfAbsent(threadId, new LoggingObject());
        threadLogMap.get(threadId).setID(taskInfo.getTaskId());
    }

    after() returning(TaskStatus status): processMethodExecution(TaskInformation) {
        long threadId = Thread.currentThread().getId();
        LoggingObject log = threadLogMap.get(threadId);
        log.setStatus(status);
        logger.info("Process summary: " + log.toString());
        // 清理避免内存泄漏
        threadLogMap.remove(threadId);
    }
}

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