[Performance] Optimize Bean Async Initialization with Smart Analysis

[CrazyHZM]

中文描述

背景

SOFABoot 已支持 SofaAsyncInit 注解用于异步初始化 Bean，但默认配置不够激进，很多 Bean 仍串行初始化，缺少自动识别可异步初始化 Bean 的机制。

当前问题

1. 默认 asyncInit 功能关闭，需要显式开启
2. 缺少依赖分析，存在依赖关系的 Bean 可能被异步初始化导致问题
3. 没有统一的异步初始化线程池管理

建议实现方案

1. 智能依赖分析器

@Component
public class SmartAsyncInitAnalyzer {

    public List<BeanDefinition> analyzeAsyncCandidates(
            ConfigurableListableBeanFactory beanFactory) {
        List<BeanDefinition> candidates = new ArrayList<>();

        for (String beanName : beanFactory.getBeanDefinitionNames()) {
            BeanDefinition bd = beanFactory.getBeanDefinition(beanName);

            // 检查是否为无状态服务
            if (isStatelessService(bd) && !hasMandatoryDependencies(bd)) {
                candidates.add(bd);
            }
        }

        return candidates;
    }

    private boolean isStatelessService(BeanDefinition bd) {
        String beanClassName = bd.getBeanClassName();
        if (beanClassName == null) continue;

        Class<?> clazz = Class.forName(beanClassName);

        // 检查是否有状态注解
        return !hasStatefulAnnotations(clazz)
            && !clazz.isAnnotationPresent(Stateful.class)
            && !isConfigurationProperties(clazz);
    }

    private boolean hasMandatoryDependencies(BeanDefinition bd) {
        // 分析依赖图，检查是否存在强制依赖
        ConstructorArgumentValues cav = bd.getConstructorArgumentValues();
        return !cav.isEmpty();
    }
}

2. 增强配置属性

@ConfigurationProperties("sofa.boot.async-init")
public class AsyncInitProperties {

    /** 是否启用异步初始化 */
    private boolean enabled = true;

    /** 核心线程数 */
    private int corePoolSize = Runtime.getRuntime().availableProcessors();

    /** 最大线程数 */
    private int maxPoolSize = corePoolSize * 2;

    /** 队列容量 */
    private int queueCapacity = 100;

    /** 超时时间（毫秒） */
    private long timeoutMillis = 30000;

    /** 自动识别模式 */
    private AutoMode autoMode = AutoMode.CONSERVATIVE;

    public enum AutoMode {
        /** 关闭自动识别 */
        OFF,
        /** 保守模式（仅明确无依赖的Bean） */
        CONSERVATIVE,
        /** 激进模式（自动分析依赖） */
        AGGRESSIVE
    }
}

3. 启动优化分析器

@Component
public class StartupOptimizer {

    public StartupReport analyzeStartupBottlenecks(ApplicationContext context) {
        StartupReport report = new StartupReport();

        // 分析串行初始化的 Bean
        report.setSequentialBeans(findSequentialBeans(context));

        // 分析耗时最长的 Bean
        report.setSlowestBeans(findSlowBeans(context, 10));

        // 生成优化建议
        report.setRecommendations(generateRecommendations(report));

        return report;
    }

    private List<Recommendation> generateRecommendations(StartupReport report) {
        List<Recommendation> recommendations = new ArrayList<>();

        // 建议可异步化的 Bean
        for (BeanInitInfo slowBean : report.getSlowestBeans()) {
            if (slowBean.getInitTime() > 500 && !slowBean.isAsync()) {
                recommendations.add(new Recommendation(
                    "ASYNC_CANDIDATE",
                    slowBean.getBeanName(),
                    String.format("Bean '%s' 初始化耗时 %dms，建议添加 @SofaAsyncInit",
                        slowBean.getBeanName(), slowBean.getInitTime())
                ));
            }
        }

        return recommendations;
    }
}

4. 端点暴露优化建议

@Endpoint(id = "startup-optimization")
public class StartupOptimizationEndpoint {

    @Autowired
    private StartupOptimizer optimizer;

    @ReadOperation
    public StartupReport analyze() {
        return optimizer.analyzeStartupBottlenecks(applicationContext);
    }

    @ReadOperation
    public List<BeanInitInfo> slowBeans(@Nullable Integer top) {
        return optimizer.findSlowBeans(top != null ? top : 10);
    }
}

配置示例

sofa:
  boot:
    async-init:
      enabled: true
      auto-mode: CONSERVATIVE  # 或 AGGRESSIVE
      core-pool-size: 4
      max-pool-size: 8
      timeout-millis: 30000

预期收益

• 启动时间减少 20-40%（取决于应用复杂度）
• 自动识别可异步初始化的 Bean，减少人工配置
• 更好的线程池管理和监控

兼容性

• 向后兼容现有 @SofaAsyncInit 注解
• 默认启用，可通过 enabled: false 关闭
• 不影响已正确配置的应用

---

Description (English)

Background

SOFABoot already supports the SofaAsyncInit annotation for asynchronous Bean initialization, but the default configuration is not aggressive enough. Many Beans are still initialized sequentially, and there is no automatic mechanism to identify Beans that can be asynchronously initialized.

Current Problems

1. asyncInit is disabled by default and needs to be explicitly enabled
2. Lack of dependency analysis: Beans with dependencies may be incorrectly async initialized
3. No unified async initialization thread pool management

Suggested Implementation

1. Smart Dependency Analyzer

@Component
public class SmartAsyncInitAnalyzer {

    public List<BeanDefinition> analyzeAsyncCandidates(
            ConfigurableListableBeanFactory beanFactory) {
        List<BeanDefinition> candidates = new ArrayList<>();

        for (String beanName : beanFactory.getBeanDefinitionNames()) {
            BeanDefinition bd = beanFactory.getBeanDefinition(beanName);

            // Check if it's a stateless service
            if (isStatelessService(bd) && !hasMandatoryDependencies(bd)) {
                candidates.add(bd);
            }
        }

        return candidates;
    }
}

2. Enhanced Configuration Properties

@ConfigurationProperties("sofa.boot.async-init")
public class AsyncInitProperties {

    private boolean enabled = true;
    private int corePoolSize = Runtime.getRuntime().availableProcessors();
    private int maxPoolSize = corePoolSize * 2;
    private AutoMode autoMode = AutoMode.CONSERVATIVE;

    public enum AutoMode {
        OFF,
        CONSERVATIVE,
        AGGRESSIVE
    }
}

3. Startup Optimizer

@Component
public class StartupOptimizer {

    public StartupReport analyzeStartupBottlenecks(ApplicationContext context) {
        StartupReport report = new StartupReport();

        report.setSequentialBeans(findSequentialBeans(context));
        report.setSlowestBeans(findSlowBeans(context, 10));
        report.setRecommendations(generateRecommendations(report));

        return report;
    }
}

Expected Benefits

• Startup time reduced by 20-40% (depending on application complexity)
• Automatic identification of Beans that can be async initialized
• Better thread pool management and monitoring

/label ~enhancement ~performance ~startup