easyfk-thread 线程池

dependencies {
    compileOnly project(':easyfk-core')
}

easyfk-thread/
├── build.gradle
└── src/main/java/com/mcst/easyfk/thread/
    ├── config/
    │   ├── ThreadPoolConfig.java              # 线程池自动配置（核心）
    │   └── ThreadPoolMonitorAutoConfig.java   # 监控自动配置
    ├── properties/
    │   ├── ThreadPoolBaseProperties.java       # 线程池基础配置
    │   ├── ThreadPoolArgs.java                # 线程池参数（可复用）
    │   ├── ThreadPoolMonitorProperties.java   # 监控配置
    │   └── DynamicAdjustmentConfig.java       # 动态调整配置
    ├── CustomTaskExecutor.java                # 增强的任务执行器（TraceId 传递）
    ├── ThreadPoolMetrics.java                 # 线程池指标数据
    ├── ThreadPoolMonitor.java                 # 线程池监控器
    ├── AsyncThreadPoolMonitor.java            # 异步线程池监控器
    ├── ThreadPoolMonitorManager.java          # 监控器管理器
    ├── AdjustmentDecision.java                # 调整决策
    ├── async/
    │   └── CompletableFutureConvert.java      # CompletableFuture 转换工具
    └── retry/
        ├── RetryConfig.java                   # 重试配置
        ├── RetryContext.java                  # 重试上下文
        ├── RetryCallback.java                 # 重试回调接口
        ├── BackoffStrategy.java               # 退避策略枚举
        ├── RetryableOperation.java            # 可重试操作接口
        └── RetryExecutor.java                 # 重试执行器

easyfk:
  config:
    thread:
      pool:
        create-common-pool: true
        create-async-pool: true
        create-schedule-pool: true
        create-io-intensive-pool: true
        create-retry: true

        common-pool-args:
          core-pool-size: 8
          max-pool-size: 16
          queue-capacity: 500
          thread-name-prefix: "common-"
          rejected-execution-handler: CALLER_RUNS

        async-pool-args:
          core-pool-size: 4
          queue-capacity: 200

        io-intensive-pool-args:
          core-pool-size: 16
          max-pool-size: 32
          queue-capacity: 1000
          keep-alive-seconds: 120

        retry-pool-args:
          core-pool-size: 2
          thread-name-prefix: "retry-"

        monitor:
          enabled: true
          auto-discovery: true
          auto-start: true
          exclude-names:
            - retryScheduledExecutor
          default-config:
            monitoring-interval: 30s
            cooldown-period: 2m
            high-load-threshold: 80.0
            low-load-threshold: 30.0
            async-monitoring-enabled: true
          configs:
            commonTaskExecutor:
              high-load-threshold: 70.0
              max-core-pool-size: 30
              scale-up-step: 3

public class CustomTaskExecutor extends ThreadPoolTaskExecutor {
    @Override
    public void execute(Runnable task) {
        final String traceId = TraceIdContext.getTraceId();
        super.execute(() -> {
            try {
                if (EmptyUtil.isNotEmpty(traceId)) {
                    TraceIdContext.setTraceId(traceId);
                    MDC.put(RequestHeaderConstant.TRACE_ID, traceId);
                }
                task.run();
            } finally {
                TraceIdContext.remove();
                MDC.remove(RequestHeaderConstant.TRACE_ID);
            }
        });
    }
}

// 获取指定监控器
ThreadPoolMonitor monitor = manager.getMonitor("commonTaskExecutor");

// 获取所有统计
Map<String, Map<String, Object>> stats = manager.getAllStatistics();

// 启动/停止所有监控
manager.startAllMonitoring();
manager.stopAllMonitoring();

CompletableFuture<Result> future = CompletableFutureConvert.async(
    () -> slowService.query(param),
    5,   // 超时秒数
    ioIntensiveTaskExecutor
);

CompletableFuture<UserDto> future = CompletableFutureConvert.asyncForBaseResult(
    () -> userApi.getUser(userId),
    3,   // 超时秒数
    ioIntensiveTaskExecutor
);

// future 直接包含 UserDto，无需手动解包 BaseResult
// 失败时自动抛出 RuntimeException("REMOTE_FAIL: code:msg")

RetryConfig config = RetryConfig.builder()
    .maxRetries(3)                              // 最大重试 3 次
    .baseDelayMs(500)                           // 基础延迟 500ms
    .backoffStrategy(BackoffStrategy.LINEAR)    // 线性退避
    .maxConcurrentRetries(100)                  // 最大并发重试数
    .businessKey("pushMsg:user123")             // 业务标识
    .enableFallback(true)                       // 启用降级
    .retryFor(new Class[]{IOException.class})   // 仅重试 IO 异常
    .noRetryFor(new Class[]{IllegalArgumentException.class}) // 参数异常不重试
    .build();

@Resource
private RetryExecutor retryExecutor;

// 同步执行，失败自动重试，所有重试完成后返回或抛异常
try {
    String result = retryExecutor.execute(config, () -> {
        return httpClient.get(url);
    });
} catch (Exception e) {
    // 所有重试都失败后的异常
}

retryExecutor.executeAsync(config, () -> {
    rocketProducer.send(message);
    return null;
}, new RetryCallback<Void>() {
    @Override
    public void onSuccess(Void result, int attempt) {
        log.info("发送成功，尝试次数: {}", attempt);
    }

    @Override
    public void onFinalFailure(Exception e, int totalAttempts) {
        log.error("发送最终失败，总尝试: {}", totalAttempts, e);
    }
});