Skip to content

批处理与异步:大规模 AI 任务编排 ​

本篇要点:把「给 18 万条历史工单重新打标」这类任务做成可中断、可重跑、账单可控的批处理。前置:《可观测与护栏:成本、延迟与安全》已经能算出单次调用的成本,这一章把它乘上 18 万。

为什么需要它 ​

运营要的是「这周内把历史工单的类别重新打一遍」,一共 183,742 条。

第一版写得很直接:for (Ticket t : tickets) { client.call(...) }。单条平均 3.2 秒,串行跑完要 163 小时,六天多,中途还不能断。改成固定 32 线程的线程池,40 分钟跑了两万四千条,然后开始大量 429,重试把并发推得更高,P95 从 3 秒涨到 47 秒。

第二版加了重试和退避,跑通了。第二天因为一条脏数据(正文是空的)整批失败,运维重跑,把已经打好的 3 万条重新打了一遍:账单多一份,还有 200 多条因为两次调用返回了不同类别,写进了两条记录。

也考虑过更轻的做法。@Async 加线程池,一次 submit 18 万个任务:能跑,但没有进度、没有失败清单,进程一重启全丢。或者丢进 Kafka 让消费者慢慢消化:并发和背压有了,可「跑到哪了」「哪几条失败了」还是得自己建表记。Spring Batch 恰好把这三样做完了——执行状态、失败清单、重启位置,代价是你得按它的模型组织代码。

这里其实有三件独立的事被混在一起:怎么并发(线程池还是虚拟线程)、怎么不把下游打挂(限流)、怎么重跑不出脏数据(幂等与续跑)。分开处理,每一件都不难。

核心概念 ​

Job、Step、Chunk:三个提交边界 ​

Spring Batch 的模型只有三层:Job 是一次完整批处理,Step 是一个阶段,Chunk 是一次事务提交的条数。chunk(20) 的意思是「读 20 条、处理 20 条、写 20 条,然后提交一次事务」。

这个边界决定了三件事的行为:失败时回滚多少、重启时从哪里接、内存里最多攒多少。类比:翻书时一次翻 20 页夹个书签,书掉地上从书签处接着读,不用回第一页。

反例:chunk(1000)。看着快,实际上 1000 次模型调用攒在一个事务里,第 999 条失败时前面 998 条的钱白花,事务还得回滚。模型调用是不可回滚的外部副作用,chunk 必须小,我的经验值是 10 到 30。

JobInstance 与 JobParameters:重跑靠什么标识 ​

Spring Batch 用 JobParameters 算 JobInstance 的标识。参数完全相同的 Job 第二次启动会抛 JobInstanceAlreadyCompleteException,因为框架认为「这个任务已经跑完了」。

这条规则经常被当成 bug。它的本意是防重复执行,而批量重跑恰恰需要「同参数再来一次」,所以要么加 RunIdIncrementer(每次运行生成新的 run.id),要么把日期这类业务参数带上。加了之后就得自己保证幂等,框架不再帮你挡重复。

虚拟线程:让等待变便宜,不让配额变宽 ​

模型调用是典型的 IO 等待:请求发出去之后 2 到 20 秒什么都不干,却一直占着线程。平台线程池默认就 200 来个,32 并发之后剩下的全在队列里排。虚拟线程(virtual thread)把这种等待的代价降到几乎为零,几万并发在内存上都撑得住。

但它不会让下游的配额变大。供应商给的 RPM 和 TPM 是固定的,虚拟线程只会让你更快撞上去。所以虚拟线程必须配限流一起上,单独上等于给自己制造 429。

反例:Executors.newVirtualThreadPerTaskExecutor() 直接 submit 18 万个任务。这不会更快,只会让头 500 个请求同时被拒。

并发数该怎么算 ​

不要凭感觉。先测三个数:单次调用平均耗时 T(比如 3.2 秒)、供应商给的 RPM(比如每分钟 600 次)、你自己的 TPM 预算。按利特尔法则,稳态下并发数约等于「每秒请求数 × T」。RPM 600 折合每秒 10 次,10 × 3.2 约等于 32,也就是说 32 并发刚好贴着上限跑,没有余量;想留三成余量就取 22 到 24。

代码里 concurrency: 24 就是这么来的,不是拍脑袋。反例:按「CPU 核数 × 2」设并发——模型调用的瓶颈在远端,跟本机核数没有关系,4 核机器和 64 核机器该用的是同一个并发数。

限流与重试:一个管数量,一个管单次 ​

限流(rate limiting)控制同时在飞或每秒的请求数,重试(retry)处理单次失败。两者管的不是一回事,不能互相替代。

用重试代替限流的后果是:下游越慢,重试越多,下游更慢。这叫重试风暴。正确的组合是 Semaphore 或令牌桶卡住并发上限,失败后指数退避加随机抖动重试,重试到上限就进死信表。

幂等与断点续跑:两个不同的问题 ​

幂等(idempotency)保证同一输入算两次结果一致、且不产生第二条记录。断点续跑(restart)保证中断后从上次的位置继续,不从头再来。

前者防脏,后者防浪费。很多人只做了后者,于是重跑虽然快了,重复数据照样进库。

表 9-1 四类失败各自该在哪里处理

失败类型典型症状处理位置处理方式
限流 429短时间大量被拒调用前Semaphore 卡并发 + 退避重试
超时与网络抖动偶发 ResourceAccessException单条调用指数退避重试 3 次,带随机抖动
内容不合格返回空、解析失败单条处理重试一次后落死信表,不阻塞整批
数据本身脏正文为空、字段缺失读取阶段直接 skip 并记录原因

如图 9-1 所示,一个分块步骤的失败有四种去向,只有「瞬时可重试的错误」该回到队列,其余三种都应该往前走。

图 9-1 分块步骤的四种失败去向与续跑入口

动手实践 ​

依赖:

xml
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-starter-model-openai</artifactId>
</dependency>
<dependency>
  <groupId>org.postgresql</groupId>
  <artifactId>postgresql</artifactId>
  <scope>runtime</scope>
</dependency>

版本基线:Spring Batch 6.0.x,截至 2026 年 11 月参考文档为 6.0.6。JobBuilderFactory 与 StepBuilderFactory 在 6.0 已经移除,一律用构造器 new JobBuilder(name, jobRepository)。虚拟线程需要 Java 21 以上。

配置:

yaml
spring:
  threads:
    virtual:
      enabled: true
  batch:
    job:
      enabled: false            # 别让应用一启动就跑批,改由接口或定时器触发
    jdbc:
      initialize-schema: always # 仅本地;生产用迁移脚本建 BATCH_* 表
  datasource:
    url: jdbc:postgresql://localhost:5432/ops
    username: ops
    password: ${DB_PASSWORD}

ai:
  batch:
    concurrency: 24             # 在飞请求上限

第一步:把 Job 和 Step 搭起来 ​

代码 9-1 是完整配置。注意顺序:taskExecutor 要在 faultTolerant() 之前设,之后调会拿不到分块执行器。

java
package com.example.aibatch;

import java.util.Map;

import javax.sql.DataSource;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.item.database.JdbcPagingItemReader;
import org.springframework.batch.item.database.Order;
import org.springframework.batch.item.database.builder.JdbcPagingItemReaderBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.VirtualThreadTaskExecutor;
import org.springframework.retry.backoff.ExponentialBackOffPolicy;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.web.client.HttpServerErrorException;
import org.springframework.web.client.ResourceAccessException;

@Configuration
public class TicketTaggingJobConfig {

    @Bean
    public JdbcPagingItemReader<TicketRow> ticketReader(DataSource dataSource) {
        return new JdbcPagingItemReaderBuilder<TicketRow>()
                .name("ticketReader")
                .dataSource(dataSource)
                .pageSize(20)
                .selectClause("id, title, body")
                .fromClause("tickets")
                .whereClause("status = 'OPEN'")
                .sortKeys(Map.of("id", Order.ASCENDING))
                .rowMapper((rs, i) -> new TicketRow(rs.getLong("id"),
                        rs.getString("title"), rs.getString("body")))
                .build();
    }

    @Bean
    public Step tagStep(JobRepository jobRepository,
                        PlatformTransactionManager txManager,
                        JdbcPagingItemReader<TicketRow> ticketReader,
                        TicketTagProcessor processor,
                        TagResultWriter writer) {
        ExponentialBackOffPolicy backoff = new ExponentialBackOffPolicy();
        backoff.setInitialInterval(1_000);
        backoff.setMultiplier(2.0);
        backoff.setMaxInterval(15_000);

        return new StepBuilder("tagStep", jobRepository)
                .<TicketRow, TagResult>chunk(20, txManager)
                .reader(ticketReader)
                .processor(processor)
                .writer(writer)
                .taskExecutor(new VirtualThreadTaskExecutor("ai-batch-"))
                .faultTolerant()
                .retry(ResourceAccessException.class)
                .retry(HttpServerErrorException.class)
                .retryLimit(3)
                .backoffPolicy(backoff)
                .skip(IllegalArgumentException.class)
                .skipLimit(50)
                .build();
    }

    @Bean
    public Job ticketTaggingJob(JobRepository jobRepository, Step tagStep) {
        return new JobBuilder("ticketTaggingJob", jobRepository)
                .start(tagStep)
                .incrementer(new RunIdIncrementer())
                .build();
    }
}

运行结果(spring.batch.job.enabled=false,用接口手动触发):

$ curl -X POST localhost:8080/batch/tickets
2026-11-16T21:14:02.318+08:00  INFO 41211 --- [ai-batch-2] c.e.a.TicketTagProcessor : 处理工单 id=184001
2026-11-17T04:02:55.902+08:00  INFO 41211 --- [           main] o.s.b.c.l.s.SimpleJobLauncher : Job: [SimpleJob: [name=ticketTaggingJob]] completed with the following parameters: [{run.id=1, ts=1763308442318}] and status: [COMPLETED]
2026-11-17T04:02:55.905+08:00  INFO 41211 --- [           main] c.e.a.BatchReportService : 总数=183742 成功=182910 跳过=812 死信=20 耗时=24472s

六个半小时,和估算对得上:183742 乘 3.2 秒再除以 24,约 24,499 秒。跳过 812 条里,绝大多数是正文为空——它们没有花过一次模型调用,这个拆分要在报表里单独列,否则你会以为「跳过」是失败。

第二步:让处理器自己管限流、幂等和失败分类 ​

代码 9-2:ItemProcessor 返回 null 表示这条被过滤掉,Spring Batch 会跳过它,不交给 writer。

java
package com.example.aibatch;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
public class TicketTagProcessor implements ItemProcessor<TicketRow, TagResult> {

    private final ChatClient chatClient;
    private final JdbcTemplate jdbc;
    private final Semaphore permits;

    public TicketTagProcessor(ChatClient chatClient, JdbcTemplate jdbc,
                              @Value("${ai.batch.concurrency:24}") int concurrency) {
        this.chatClient = chatClient;
        this.jdbc = jdbc;
        this.permits = new Semaphore(concurrency);
    }

    @Override
    public TagResult process(TicketRow row) throws InterruptedException {
        if (row.body() == null || row.body().isBlank()) {
            // 数据脏:交给 skip 策略,不占重试次数
            throw new IllegalArgumentException("工单正文为空 id=" + row.id());
        }
        // 幂等闸门:算过的直接过滤,不花第二次钱
        Integer done = jdbc.queryForObject(
                "SELECT count(1) FROM ticket_tag_done WHERE ticket_id = ?",
                Integer.class, row.id());
        if (done != null && done > 0) {
            return null;
        }

        if (!permits.tryAcquire(30, TimeUnit.SECONDS)) {
            throw new IllegalStateException("等限流许可超时 id=" + row.id());
        }
        try {
            Tag tag = chatClient.prompt()
                    .system("你是工单分类器,只输出给定枚举中的一个类别,不要解释。")
                    .user("标题:" + row.title() + "\n正文:" + row.body())
                    .call()
                    .entity(Tag.class);
            return new TagResult(row.id(), tag.category(), tag.confidence());
        } finally {
            permits.release();
        }
    }
}

运行结果(第一次跑完之后,用同一个 Job 再触发一次):

$ curl -X POST localhost:8080/batch/tickets
2026-11-16T22:03:11.004+08:00  INFO 41288 --- [           main] c.e.a.BatchReportService : 总数=183742 成功=0 跳过=183742 死信=0 耗时=214s

总数 18 万、成功 0,看着像失败,其实是幂等闸门生效了:全部判定为已处理,一次模型调用都没有,账单是 0。这 214 秒基本花在 18 万次 count(1) 上,所以正式版把去重表换成了 Redis 的 SET NX 做批量预筛。

第三步:断点续跑 ​

周三那次跑到 4.5 小时被发布流程打断,库里剩 61,211 条没处理。用 JobOperator 从上次失败的执行接着跑:

java
package com.example.aibatch;

import java.util.List;

import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobInstance;
import org.springframework.batch.core.explore.JobExplorer;
import org.springframework.batch.core.launch.JobOperator;
import org.springframework.stereotype.Service;

@Service
public class BatchRestartService {

    private final JobExplorer jobExplorer;
    private final JobOperator jobOperator;

    public BatchRestartService(JobExplorer jobExplorer, JobOperator jobOperator) {
        this.jobExplorer = jobExplorer;
        this.jobOperator = jobOperator;
    }

    public Long restartLastFailed(String jobName) throws Exception {
        List<JobInstance> instances = jobExplorer.getJobInstances(jobName, 0, 1);
        if (instances.isEmpty()) {
            return null;
        }
        JobExecution last = jobExplorer.getLastJobExecution(instances.get(0));
        if (last == null || last.getStatus() != BatchStatus.FAILED) {
            return null;
        }
        return jobOperator.restart(last.getId());
    }
}

运行结果:

$ curl -X POST localhost:8080/batch/tickets/restart
2026-11-18T09:02:44.120+08:00  INFO 50112 --- [           main] c.e.a.BatchRestartService : restart executionId=2
2026-11-18T11:13:02.553+08:00  INFO 50112 --- [           main] c.e.a.BatchReportService : 总数=61211 成功=60980 跳过=211 死信=20 耗时=7818s

18 万条的任务只处理了 6 万条,说明 reader 的 ExecutionContext 被复用了,从上次提交的位置接着读。这条能成立有个前提:读器必须可重启。JdbcPagingItemReader 会保存分页位置;游标读器中断后的游标位置不可靠,所以批量任务里我不用它。

死信表那 20 条是重试耗尽的,跑完不会自动消失。我的做法是让它进运维看板、按天清零,人工改完数据后用一条独立的小 Job 重投,而不是把 skipLimit 调大蒙过去。skipLimit 设 50 也是这个意思:它是「容忍边角料」的额度,不是「掩盖系统性问题」的开关。

常见误解 ​

很多人以为上了虚拟线程吞吐就会涨。 其实涨不涨取决于下游配额和你自己的限流。虚拟线程只是把「等待」从占一个线程变成几乎不占资源;没限流时并发越高错误率越高,P95 反而更差——《可观测与护栏:成本、延迟与安全》那套指标在这里就是判据,看的是 gen_ai_client_operation_seconds 和 429 比例,不是线程数。

很多人以为 Spring Batch 重跑会自动跳过已处理的数据。 其实它只按 JobParameters 认 JobInstance:参数变了就是新实例,旧进度不复用;参数没变时,被 skip 掉的数据也会重新读到。幂等要自己在处理器或写入口做,唯一键或去重表都行。

很多人以为 chunk 越大越快。 其实 chunk 是事务边界,模型调用又是不可回滚的外部副作用。把 chunk 从 20 调到 500,吞吐几乎不变(瓶颈在限流),但一次失败要重跑的量按比例放大,重跑成本跟着涨。

小结 ​

  • Job、Step、Chunk 三层,chunk 是事务边界;模型调用不可回滚,chunk 要小,10 到 30 是常用区间。
  • 虚拟线程解决等待,不解决配额,必须和 Semaphore 或令牌桶一起上。
  • 重试只对瞬时错误有意义(429、超时、5xx);数据脏和内容不合格应该 skip 或进死信表。
  • 幂等防脏,续跑防浪费,两件事分别做:唯一键或去重表 + 可重启的读器。
  • spring.batch.job.enabled=false,别让批任务跟着应用启动就跑。

相关主题 ​

这套流程上线前还有一道关:你怎么证明这次改动没有把结果搞坏?《AI 功能的测试策略》讲测试策略——为什么把 ChatClient mock 掉等于没测、录制回放怎么落地、Prompt 改了之后回归怎么在 CI 里跑得起又烧不了多少钱。