在 Spring @Scheduled 任务中实现线程上下文自动清理的教程

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

@Configuration
@EnableScheduling // 启用Spring的调度功能
public class SchedulingConfiguration implements SchedulingConfigurer {

  @Override
  public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
    // 创建并初始化自定义的ThreadPoolTaskScheduler
    CustomThreadPoolTaskScheduler threadPoolTaskScheduler = new CustomThreadPoolTaskScheduler();
    threadPoolTaskScheduler.initialize(); // 必须调用initialize方法来启动调度器

    // 将自定义的调度器设置给任务注册器
    taskRegistrar.setTaskScheduler(threadPoolTaskScheduler);
  }
}

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

public class CustomThreadPoolTaskScheduler extends ThreadPoolTaskScheduler {

  @Override
  protected ScheduledExecutorService createExecutor(
      int poolSize,
      ThreadFactory threadFactory,
      RejectedExecutionHandler rejectedExecutionHandler) {
    // 返回我们自定义的ScheduledThreadPoolExecutor实例
    return new CustomScheduledThreadPoolExecutor(poolSize, threadFactory, rejectedExecutionHandler);
  }
}

import java.util.concurrent.*;
import org.springframework.lang.Nullable; // 确保导入Nullable注解

public class CustomScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor {

  public CustomScheduledThreadPoolExecutor(
      int corePoolSize,
      ThreadFactory threadFactory,
      RejectedExecutionHandler handler) {
    super(corePoolSize, threadFactory, handler);
  }

  @Override
  protected <V> RunnableScheduledFuture<V> decorateTask(
      Callable<V> callable, RunnableScheduledFuture<V> task) {
    // 装饰Callable任务
    return new CustomTask<>(task);
  }

  @Override
  protected <V> RunnableScheduledFuture<V> decorateTask(
      Runnable runnable, RunnableScheduledFuture<V> task) {
    // 装饰Runnable任务
    return new CustomTask<>(task);
  }

  // 使用Java 16+的record语法，或者传统的内部类实现
  private record CustomTask<V>(RunnableScheduledFuture<V> task)
      implements RunnableScheduledFuture<V> {

    @Override
    public void run() {
      try {
        // 可以在这里执行任务前的操作
        // 例如：设置一些线程上下文，如果需要的话

        task.run(); // 执行原始任务
      } finally {
        // !!! 在这里执行线程上下文清理逻辑 !!!
        // 示例：GeneralUtils.clearContext();
        // 实际应用中，您需要根据自己的上下文管理工具替换此行
        System.out.println("Scheduled task finished. Clearing thread context...");
        // 例如，如果使用ThreadLocal存储用户ID:
        // CurrentUserContext.clear();
      }
    }

    // 以下方法是RunnableScheduledFuture接口的委托实现
    // 它们只是简单地调用被包装任务的对应方法
    @Override
    public boolean cancel(boolean mayInterruptIfRunning) {
      return task.cancel(mayInterruptIfRunning);
    }

    @Override
    public boolean isCancelled() {
      return task.isCancelled();
    }

    @Override
    public boolean isDone() {
      return task.isDone();
    }

    @Override
    public V get() throws InterruptedException, ExecutionException {
      return task.get();
    }

    @Override
    public V get(long timeout, @Nullable TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
      return task.get(timeout, unit);
    }

    @Override
    public long getDelay(@Nullable TimeUnit unit) {
      return task.getDelay(unit);
    }

    @Override
    public int compareTo(@Nullable Delayed o) {
      return task.compareTo(o);
    }

    @Override
    public boolean isPeriodic() {
      return task.isPeriodic();
    }
  }
}

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class MyScheduledTasks {

    // 假设您有一个ThreadLocal来存储请求ID
    private static final ThreadLocal<String> REQUEST_ID_CONTEXT = new ThreadLocal<>();

    @Scheduled(fixedDelayString = "10000") // 每10秒执行一次
    public void doSomething() {
        // 模拟设置上下文
        REQUEST_ID_CONTEXT.set("REQUEST-" + System.currentTimeMillis());
        System.out.println("Task executing with context: " + REQUEST_ID_CONTEXT.get() + " on thread: " + Thread.currentThread().getName());

        // 模拟任务逻辑
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Task finished. Context should be cleared soon.");
        // 注意：这里不需要手动清理，因为CustomTask的finally块会处理
    }

    // 假设您的GeneralUtils.clearContext()会清理REQUEST_ID_CONTEXT
    // 实际的清理逻辑应该在CustomTask的finally块中实现
    // public static class GeneralUtils {
    //     public static void clearContext() {
    //         REQUEST_ID_CONTEXT.remove();
    //         System.out.println("Context cleared by GeneralUtils.clearContext()");
    //     }
    // }
}