工程化03：性能优化

大模型应用的性能优化不只是提升响应速度，还要保证系统在高并发下的稳定性。需要从首字延迟、并发控制、队列削峰、异步处理等多个维度入手。

首字延迟优化

首字延迟的影响

延迟范围	用户体验	影响
< 1秒	流畅	用户无感知等待
1-3秒	可接受	用户会注意到延迟
3-5秒	较差	用户可能会重试
> 5秒	很差	用户大概率会离开

首字延迟优化策略

策略	说明	预期效果
使用流式输出	边生成边返回	减少感知延迟 50%+
选择更快的模型	使用 Haiku 等小模型	降低延迟 60%+
预热连接	提前建立 TCP 连接	减少 200-500ms
本地缓存	高频请求直接返回	延迟降低到毫秒级
边缘部署	靠近用户部署	减少网络延迟

预热连接实现

@Service
public class ModelConnectionPool {
    private final WebClient webClient;
    private final ScheduledExecutorService scheduler;
    
    @PostConstruct
    public void init() {
        // 预热连接
        scheduler.scheduleAtFixedRate(() -> {
            webClient.head()
                .uri("https://api.openai.com/v1/chat/completions")
                .retrieve()
                .toBodilessEntity()
                .subscribe();
        }, 0, 5, TimeUnit.MINUTES);
    }
}

并发控制

并发模型设计

模型	说明	适用场景
固定线程池	固定数量的工作线程	CPU 密集型任务
弹性线程池	根据负载动态调整线程数	IO 密集型任务
事件驱动	基于 Reactor 模式	高并发场景
协程	轻量级线程	大量并发任务

并发池配置

@Configuration
public class ThreadPoolConfig {
    @Bean("modelExecutor")
    public Executor modelExecutor() {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            10,          // 核心线程数
            50,          // 最大线程数
            60,          // 空闲线程存活时间(秒)
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(100), // 任务队列
            new ThreadFactory() {
                private final AtomicInteger counter = new AtomicInteger(0);
                @Override
                public Thread newThread(Runnable r) {
                    Thread t = new Thread(r);
                    t.setName("model-worker-" + counter.incrementAndGet());
                    return t;
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );
        executor.prestartAllCoreThreads();
        return executor;
    }
}

并发监控

指标	说明	告警阈值
活跃线程数	当前正在执行的线程数	> 最大线程数的 80%
队列深度	等待执行的任务数	> 队列容量的 80%
拒绝次数	被拒绝的任务数	> 0（需要关注）
平均执行时间	任务平均执行时间	超过预期 2 倍

队列削峰

削峰场景

场景	问题	解决方案
流量突增	请求量超过系统容量	使用队列缓冲
批量任务	大量任务同时到达	分批处理
大模型慢响应	单个请求耗时过长	异步处理
资源竞争	多个请求竞争资源	排队处理

队列实现示例

@Service
public class TaskQueueService {
    private final Queue<Task> taskQueue = new LinkedBlockingQueue<>(1000);
    private final ExecutorService workerPool = Executors.newFixedThreadPool(10);
    
    @PostConstruct
    public void startWorkers() {
        for (int i = 0; i < 10; i++) {
            workerPool.submit(this::processTasks);
        }
    }
    
    public void submitTask(Task task) {
        boolean accepted = taskQueue.offer(task);
        if (!accepted) {
            throw new TaskQueueFullException();
        }
    }
    
    private void processTasks() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                Task task = taskQueue.take();
                modelService.process(task);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

队列监控指标

指标	说明	告警阈值
队列长度	当前等待任务数	> 队列容量的 80%
入队速率	每秒入队任务数	持续高于处理速率
出队速率	每秒完成任务数	低于入队速率
平均等待时间	任务平均等待时间	> 10 秒

长任务异步化

异步化场景

场景	同步问题	异步方案
长文本生成	等待时间长	异步生成 + 轮询
批量处理	阻塞主线程	异步队列 + 回调
复杂任务链	多个步骤串行	异步编排
定时任务	影响实时请求	独立线程池

异步处理实现

@Service
public class AsyncModelService {
    private final ExecutorService executorService;
    private final Map<String, CompletableFuture<String>> taskMap = new ConcurrentHashMap<>();
    
    public String submitAsync(String prompt) {
        String taskId = UUID.randomUUID().toString();
        CompletableFuture<String> future = CompletableFuture.supplyAsync(
            () -> modelService.generate(prompt),
            executorService
        );
        taskMap.put(taskId, future);
        
        // 完成后清理
        future.whenComplete((result, error) -> taskMap.remove(taskId));
        
        return taskId;
    }
    
    public String getResult(String taskId) {
        CompletableFuture<String> future = taskMap.get(taskId);
        if (future == null) {
            throw new TaskNotFoundException();
        }
        if (!future.isDone()) {
            throw new TaskNotCompletedException();
        }
        return future.join();
    }
}

异步任务状态管理

状态	说明	处理方式
PENDING	等待执行	返回任务ID，让客户端轮询
RUNNING	执行中	返回进度信息
COMPLETED	执行完成	返回结果
FAILED	执行失败	返回错误信息
TIMEOUT	超时	返回超时错误

性能监控体系

监控指标

维度	指标	说明
延迟	首字延迟	用户感知的第一字节时间
延迟	总延迟	请求从开始到完成的总时间
延迟	P99延迟	99%请求的最大延迟
吞吐量	QPS	每秒处理请求数
吞吐量	并发数	同时处理的请求数
错误率	成功率	请求成功比例
错误率	超时率	请求超时比例
资源	CPU 使用率	服务器 CPU 使用率
资源	内存使用率	服务器内存使用率

监控实现示例

@Component
public class PerformanceFilter implements Filter {
    private final MeterRegistry meterRegistry;
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) throws IOException, ServletException {
        long startTime = System.currentTimeMillis();
        
        try {
            chain.doFilter(request, response);
        } finally {
            long duration = System.currentTimeMillis() - startTime;
            meterRegistry.timer("model.request.duration").record(duration, TimeUnit.MILLISECONDS);
            meterRegistry.counter("model.request.count").increment();
        }
    }
}

性能优化最佳实践

优化优先级

优先级	优化项	预期收益
P0	流式输出	减少感知延迟
P0	本地缓存	毫秒级响应
P1	并发控制	保证稳定性
P1	队列削峰	应对流量突增
P2	预热连接	减少连接开销
P2	异步处理	提升吞吐量

性能测试流程

1. 基准测试：建立性能基线
2. 压力测试：模拟高并发场景
3. 瓶颈分析：定位性能瓶颈
4. 优化实施：实施优化方案
5. 回归测试：验证优化效果
6. 持续监控：保持性能稳定

性能预算

指标	预算值	说明
首字延迟	< 1秒	用户感知的第一字节时间
总延迟	< 3秒	请求完成时间
P99延迟	< 5秒	99%请求的最大延迟
QPS	> 1000	每秒处理请求数
成功率	> 99.9%	请求成功比例

常见问题与解决方案

问题1：首字延迟过高

表现：用户等待时间过长

解决方案：

• 使用流式输出
• 选择更快的模型
• 预热连接
• 增加缓存命中率

问题2：并发请求导致系统崩溃

表现：高并发下系统无响应

解决方案：

• 设置并发上限
• 使用队列缓冲
• 实现限流
• 增加资源

问题3：长任务阻塞系统

表现：长时间任务占用资源

解决方案：

• 异步化处理
• 使用独立线程池
• 设置任务超时
• 分批处理

问题4：性能波动大

表现：响应时间不稳定

解决方案：

• 监控性能指标
• 分析波动原因
• 优化资源分配
• 增加缓存稳定性

项目判断清单

• 用户等待时间长 → 优化首字延迟
• 高并发下不稳定 → 实现并发控制
• 流量突增导致崩溃 → 使用队列削峰
• 长任务阻塞系统 → 异步化处理
• 响应时间不稳定 → 建立性能监控
• 需要保证服务质量 → 设置性能预算
• 需要应对突发流量 → 实现弹性扩缩容
• 需要长期优化 → 建立性能测试体系