批处理与异步:大规模 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 分块步骤的四种失败去向与续跑入口
动手实践
依赖:
<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 以上。
配置:
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() 之前设,之后调会拿不到分块执行器。
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。
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 从上次失败的执行接着跑:
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 耗时=7818s18 万条的任务只处理了 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 里跑得起又烧不了多少钱。