🚀 完整性能优化指南 | 缓存 + 异步 + 批处理 + 模型优化 | 实战代码 + 性能对比数据
📊 为什么需要性能优化？
现实问题
在使用AI Agent时，你是否遇到过这些问题：
- ❌ 用户提问后等待5-10秒才有回复
- ❌ 并发用户增多时系统卡顿甚至崩溃
- ❌ API调用费用居高不下
- ❌ 用户体验差，留存率低
性能瓶颈直接影响：
- 用户满意度 ⬇️
- 系统可扩展性 ⬇️
- 运营成本 ⬆️
- 商业竞争力 ⬇️
🎯 优化目标
| 指标 | 优化前 | 优化后 | 提升倍数 |
|---|---|---|---|
| 平均响应时间 | 3-5秒 | 200-500ms | 6-10倍 |
| P95响应时间 | 8-10秒 | 800ms-1s | 8-10倍 |
| 并发处理能力 | 10 QPS | 100+ QPS | 10倍+ |
| API成本 | ¥100/天 | ¥20/天 | 降低80% |
🔧 核心优化策略
策略总览
┌─────────────────────────────────────┐
│ Agent性能优化四大支柱 │
├──────────┬──────────┬───────────────┤
│ 缓存层 │ 异步处理 │ 批处理优化 │
│ (Cache) │ (Async) │ (Batching) │
├──────────┴──────────┴───────────────┤
│ 模型层优化 │
│ (Model Optimization) │
└─────────────────────────────────────┘
1️⃣ 缓存策略：避免重复计算
原理
核心思想： 相同的问题不应该重复调用LLM
用户提问 → 检查缓存 → 命中？→ 直接返回（<10ms）
↓ 未命中
调用LLM → 存储结果 → 返回（2-5秒）
实现方案
方案A：内存缓存（适合单机）
import hashlib
import time
from typing import Optional
from functools import lru_cache
class MemoryCache:
"""基于内存的简单缓存"""
def __init__(self, ttl=3600):
self.cache = {}
self.ttl = ttl # 缓存过期时间（秒）
def _generate_key(self, query: str, context: str = "") -> str:
"""生成缓存键"""
content = f"{query}:{context}"
return hashlib.md5(content.encode()).hexdigest()
def get(self, query: str, context: str = "") -> Optional[str]:
"""获取缓存"""
key = self._generate_key(query, context)
if key in self.cache:
value, timestamp = self.cache[key]
if time.time() - timestamp < self.ttl:
print(f"✅ 缓存命中: {query[:30]}...")
return value
else:
# 过期了，删除
del self.cache[key]
return None
def set(self, query: str, response: str, context: str = ""):
"""设置缓存"""
key = self._generate_key(query, context)
self.cache[key] = (response, time.time())
def clear(self):
"""清空缓存"""
self.cache.clear()
def stats(self):
"""缓存统计"""
return {
"size": len(self.cache),
"keys": list(self.cache.keys())[:5] # 显示前5个
}
# 使用示例
cache = MemoryCache(ttl=3600)
def query_with_cache(user_question: str, context: str = "") -> str:
"""带缓存的查询函数"""
# 1. 尝试从缓存获取
cached_response = cache.get(user_question, context)
if cached_response:
return cached_response
# 2. 缓存未命中，调用LLM
print("❌ 缓存未命中，调用LLM...")
response = call_llm(user_question, context) # 假设的LLM调用
# 3. 存入缓存
cache.set(user_question, response, context)
return response
性能提升：
- 缓存命中率50%时，平均响应时间降低 50%
- 缓存命中率80%时，平均响应时间降低 80%
方案B：Redis缓存（适合分布式）
import redis
import json
from typing import Optional
class RedisCache:
"""基于Redis的分布式缓存"""
def __init__(self, host='localhost', port=6379, db=0, ttl=3600):
self.redis_client = redis.Redis(host=host, port=port, db=db)
self.ttl = ttl
def _generate_key(self, query: str, context: str = "") -> str:
"""生成缓存键"""
import hashlib
content = f"agent:{query}:{context}"
return hashlib.md5(content.encode()).hexdigest()
def get(self, query: str, context: str = "") -> Optional[str]:
"""获取缓存"""
key = self._generate_key(query, context)
value = self.redis_client.get(key)
if value:
print(f"✅ Redis缓存命中")
return value.decode('utf-8')
return None
def set(self, query: str, response: str, context: str = ""):
"""设置缓存（带过期时间）"""
key = self._generate_key(query, context)
self.redis_client.setex(key, self.ttl, response)
def delete(self, query: str, context: str = ""):
"""删除缓存"""
key = self._generate_key(query, context)
self.redis_client.delete(key)
def clear_pattern(self, pattern: str = "agent:*"):
"""批量删除"""
keys = self.redis_client.keys(pattern)
if keys:
self.redis_client.delete(*keys)
# 使用示例
redis_cache = RedisCache(host='localhost', port=6379, ttl=7200)
# 在Agent中使用
def agent_query_with_redis(user_question: str) -> str:
cached = redis_cache.get(user_question)
if cached:
return cached
response = call_llm(user_question)
redis_cache.set(user_question, response)
return response
优势：
- ✅ 支持分布式部署
- ✅ 持久化存储
- ✅ 支持集群
- ✅ 性能优异（亚毫秒级）
方案C：语义缓存（高级）
问题： 传统缓存只能匹配完全相同的问题
解决方案： 使用向量相似度匹配语义相似的问题
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
import numpy as np
class SemanticCache:
"""基于语义相似度的智能缓存"""
def __init__(self, similarity_threshold=0.95):
self.embeddings = OpenAIEmbeddings()
self.vectorstore = Chroma(embedding_function=self.embeddings)
self.threshold = similarity_threshold
self.responses = {} # 存储原始回答
def _generate_id(self, query: str) -> str:
"""生成唯一ID"""
import hashlib
return hashlib.md5(query.encode()).hexdigest()
def search_similar(self, query: str, top_k=1) -> Optional[str]:
"""搜索语义相似的问题"""
# 向量检索
results = self.vectorstore.similarity_search_with_score(query, k=top_k)
if results:
doc, score = results[0]
similarity = 1 - score # 转换为相似度
if similarity >= self.threshold:
print(f"✅ 语义缓存命中 (相似度: {similarity:.2f})")
query_id = doc.metadata['id']
return self.responses.get(query_id)
return None
def add_to_cache(self, query: str, response: str):
"""添加到语义缓存"""
query_id = self._generate_id(query)
# 存储到向量数据库
self.vectorstore.add_texts(
texts=[query],
metadatas=[{'id': query_id}]
)
# 存储回答
self.responses[query_id] = response
def clear(self):
"""清空缓存"""
self.vectorstore.delete_collection()
self.responses.clear()
# 使用示例
semantic_cache = SemanticCache(similarity_threshold=0.92)
def smart_agent_query(user_question: str) -> str:
# 1. 尝试语义缓存
cached = semantic_cache.search_similar(user_question)
if cached:
return cached
# 2. 调用LLM
response = call_llm(user_question)
# 3. 存入语义缓存
semantic_cache.add_to_cache(user_question, response)
return response
# 测试
print(smart_agent_query("公司的报销政策是什么？"))
# 第一次：调用LLM（慢）
print(smart_agent_query("公司报销规定是怎样的？"))
# 第二次：语义缓存命中（快！）虽然 wording 不同，但意思相同
优势：
- ✅ 能识别语义相似的问题
- ✅ 大幅提高缓存命中率
- ✅ 用户体验更好
注意：
- 需要调整相似度阈值（0.9-0.95）
- 向量检索会增加少量开销（~50ms）
缓存策略对比
| 策略 | 响应时间 | 适用场景 | 复杂度 |
|---|---|---|---|
| 内存缓存 | <1ms | 单机、小规模 | ⭐ |
| Redis缓存 | <5ms | 分布式、生产环境 | ⭐⭐ |
| 语义缓存 | 50-100ms | 高命中率需求 | ⭐⭐⭐ |
推荐组合：
第一层：内存缓存（热点数据）
第二层：Redis缓存（通用数据）
第三层：语义缓存（相似问题）
2️⃣ 异步处理：并发执行
原理
核心思想： 不要串行等待，并行执行独立任务
串行执行（慢）：
任务1 ━━━━ 2秒 ━━━━
任务2 ━━━━ 2秒 ━━━━
任务3 ━━━━ 2秒 ━━━━
总时间：6秒
并行执行（快）：
任务1 ━━━━ 2秒 ━━━━
任务2 ━━━━ 2秒 ━━━━
任务3 ━━━━ 2秒 ━━━━
总时间：2秒（提升3倍！）
实现方案
方案A：asyncio异步IO
import asyncio
import aiohttp
from typing import List
class AsyncAgent:
"""异步Agent实现"""
def __init__(self, api_key: str):
self.api_key = api_key
self.session = None
async def __aenter__(self):
self.session = aiohttp.ClientSession()
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
if self.session:
await self.session.close()
async def call_llm_async(self, prompt: str) -> str:
"""异步调用LLM"""
url = "https://api.openai.com/v1/chat/completions"
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
data = {
"model": "gpt-3.5-turbo",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.3
}
async with self.session.post(url, headers=headers, json=data) as response:
result = await response.json()
return result['choices'][0]['message']['content']
async def process_multiple_queries(self, queries: List[str]) -> List[str]:
"""并行处理多个查询"""
tasks = [self.call_llm_async(query) for query in queries]
results = await asyncio.gather(*tasks, return_exceptions=True)
# 处理异常
final_results = []
for i, result in enumerate(results):
if isinstance(result, Exception):
print(f"❌ 查询{i}失败: {result}")
final_results.append("处理失败")
else:
final_results.append(result)
return final_results
# 使用示例
async def main():
queries = [
"什么是机器学习？",
"Python有哪些优势？",
"如何学习编程？",
"AI的未来发展趋势？",
"推荐一本好书"
]
async with AsyncAgent(api_key="your-api-key") as agent:
start_time = asyncio.get_event_loop().time()
results = await agent.process_multiple_queries(queries)
end_time = asyncio.get_event_loop().time()
print(f"⏱️ 总耗时: {end_time - start_time:.2f}秒")
for i, result in enumerate(results, 1):
print(f"\n问题{i}: {queries[i-1][:20]}...")
print(f"回答: {result[:50]}...")
# 运行
asyncio.run(main())
性能对比：
- 串行执行5个查询：~10-15秒
- 并行执行5个查询：~2-3秒
- 提升：5-7倍！
方案B：多线程（CPU密集型任务）
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List
def parallel_processing(tasks: List[dict], max_workers=10) -> List:
"""多线程并行处理"""
results = []
with ThreadPoolExecutor(max_workers=max_workers) as executor:
# 提交所有任务
future_to_task = {
executor.submit(process_single_task, task): task
for task in tasks
}
# 收集结果
for future in as_completed(future_to_task):
task = future_to_task[future]
try:
result = future.result(timeout=30)
results.append({
'task': task,
'result': result,
'status': 'success'
})
except Exception as e:
results.append({
'task': task,
'error': str(e),
'status': 'failed'
})
return results
def process_single_task(task: dict) -> str:
"""处理单个任务（模拟耗时操作）"""
import time
time.sleep(1) # 模拟1秒的处理时间
return f"处理完成: {task['id']}"
# 使用示例
tasks = [{'id': i, 'data': f'data_{i}'} for i in range(20)]
start_time = time.time()
results = parallel_processing(tasks, max_workers=10)
end_time = time.time()
print(f"处理{len(tasks)}个任务")
print(f"总耗时: {end_time - start_time:.2f}秒")
print(f"成功: {sum(1 for r in results if r['status'] == 'success')}")
性能对比：
- 串行处理20个任务：~20秒
- 10线程并行：~2秒
- 提升：10倍！
方案C：消息队列（大规模异步）
import celery
from celery import Celery
# 配置Celery
app = Celery('agent_tasks', broker='redis://localhost:6379/0')
@app.task(bind=True, max_retries=3)
def async_agent_query(self, user_id: str, query: str) -> dict:
"""异步Agent查询任务"""
try:
# 调用LLM
response = call_llm(query)
# 保存结果到数据库
save_result(user_id, query, response)
return {
'status': 'success',
'response': response,
'user_id': user_id
}
except Exception as exc:
# 重试
raise self.retry(exc=exc, countdown=2 ** self.request.retries)
# 使用示例
def submit_async_query(user_id: str, query: str):
"""提交异步查询"""
task = async_agent_query.delay(user_id, query)
return task.id
def get_query_result(task_id: str):
"""获取查询结果"""
task = async_agent_query.AsyncResult(task_id)
if task.state == 'PENDING':
return {'status': 'processing'}
elif task.state == 'SUCCESS':
return {'status': 'completed', 'result': task.result}
else:
return {'status': 'failed', 'error': str(task.result)}
优势：
- ✅ 支持大规模并发
- ✅ 自动重试机制
- ✅ 任务持久化
- ✅ 易于监控
异步策略对比
| 策略 | 适用场景 | 复杂度 | 性能提升 |
|---|---|---|---|
| asyncio | IO密集型 | ⭐⭐ | 5-10倍 |
| 多线程 | CPU密集型 | ⭐⭐ | 5-10倍 |
| 消息队列 | 大规模异步 | ⭐⭐⭐ | 10-100倍 |
3️⃣ 批处理优化：减少API调用
原理
核心思想： 合并多个小请求为一个大请求
单独调用（慢且贵）：
请求1 → API → 等待2秒 → 结果
请求2 → API → 等待2秒 → 结果
请求3 → API → 等待2秒 → 结果
总时间：6秒，成本：3次调用
批处理（快且省）：
[请求1, 请求2, 请求3] → API → 等待2.5秒 → [结果1, 结果2, 结果3]
总时间：2.5秒，成本：1次调用（通常更便宜）
实现方案
方案A：请求 batching
import asyncio
from typing import List
class BatchProcessor:
"""批处理器"""
def __init__(self, batch_size=10, wait_time=0.1):
self.batch_size = batch_size
self.wait_time = wait_time
self.queue = asyncio.Queue()
self.running = False
async def start(self):
"""启动批处理循环"""
self.running = True
while self.running:
await self._process_batch()
async def _process_batch(self):
"""处理一批请求"""
batch = []
# 收集请求
while len(batch) < self.batch_size:
try:
item = await asyncio.wait_for(
self.queue.get(),
timeout=self.wait_time
)
batch.append(item)
except asyncio.TimeoutError:
break
if not batch:
return
print(f"📦 处理批次: {len(batch)}个请求")
# 批量处理
results = await self._batch_call_llm(batch)
# 返回结果
for item, result in zip(batch, results):
future, query = item
future.set_result(result)
async def _batch_call_llm(self, batch: List) -> List[str]:
"""批量调用LLM"""
queries = [item[1] for item in batch]
# 方法1：如果API支持批量
# results = await call_llm_batch(queries)
# 方法2：并发调用
tasks = [call_llm_async(query) for query in queries]
results = await asyncio.gather(*tasks)
return results
async def submit(self, query: str) -> str:
"""提交请求"""
loop = asyncio.get_event_loop()
future = loop.create_future()
await self.queue.put((future, query))
return await future
def stop(self):
"""停止批处理"""
self.running = False
# 使用示例
async def main():
processor = BatchProcessor(batch_size=5, wait_time=0.2)
# 启动批处理
asyncio.create_task(processor.start())
# 提交多个请求
queries = [f"问题{i}" for i in range(20)]
start_time = asyncio.get_event_loop().time()
tasks = [processor.submit(q) for q in queries]
results = await asyncio.gather(*tasks)
end_time = asyncio.get_event_loop().time()
print(f"处理{len(queries)}个请求")
print(f"总耗时: {end_time - start_time:.2f}秒")
print(f"平均每个请求: {(end_time - start_time) / len(queries) * 1000:.0f}ms")
asyncio.run(main())
性能提升：
- 减少API调用次数：降低60-80%
- 平均响应时间：降低40-60%
- 成本：降低50-70%
方案B：流式响应
import aiohttp
import json
async def stream_llm_response(prompt: str):
"""流式获取LLM响应"""
url = "https://api.openai.com/v1/chat/completions"
headers = {
"Authorization": "Bearer your-api-key",
"Content-Type": "application/json"
}
data = {
"model": "gpt-3.5-turbo",
"messages": [{"role": "user", "content": prompt}],
"stream": True # 启用流式
}
async with aiohttp.ClientSession() as session:
async with session.post(url, headers=headers, json=data) as response:
full_text = ""
async for line in response.content:
if line:
line_str = line.decode('utf-8').strip()
if line_str.startswith('data: '):
data_str = line_str[6:]
if data_str == '[DONE]':
break
try:
data = json.loads(data_str)
delta = data['choices'][0].get('delta', {})
content = delta.get('content', '')
full_text += content
# 实时输出（用户体验好）
print(content, end='', flush=True)
except json.JSONDecodeError:
continue
return full_text
# 使用示例
async def main():
print("AI回答：", end='')
response = await stream_llm_response("介绍一下Python")
print(f"\n\n总长度: {len(response)}字符")
asyncio.run(main())
优势：
- ✅ 首字延迟低（<500ms）
- ✅ 用户体验好（实时看到回答）
- ✅ 可以提前终止不需要的回答
4️⃣ 模型层优化：选择合适的模型
模型选型策略
策略A：分级模型使用
class SmartModelSelector:
"""智能模型选择器"""
def __init__(self):
self.fast_model = "gpt-3.5-turbo" # 快速、便宜
self.balanced_model = "gpt-4o-mini" # 平衡
self.smart_model = "gpt-4o" # 智能、贵
def select_model(self, query: str, context: dict) -> str:
"""根据问题复杂度选择模型"""
# 简单问题：使用快速模型
if self._is_simple_query(query):
return self.fast_model
# 中等复杂：使用平衡模型
elif self._is_medium_complexity(query, context):
return self.balanced_model
# 复杂问题：使用智能模型
else:
return self.smart_model
def _is_simple_query(self, query: str) -> bool:
"""判断是否为简单问题"""
simple_keywords = ['是什么', '多少钱', '几点', '天气']
return any(kw in query for kw in simple_keywords) and len(query) < 50
def _is_medium_complexity(self, query: str, context: dict) -> bool:
"""判断是否为中等复杂度"""
return len(query) < 200 and not context.get('requires_reasoning', False)
# 使用示例
selector = SmartModelSelector()
def optimized_query(user_question: str, context: dict = {}) -> str:
model = selector.select_model(user_question, context)
print(f"使用模型: {model}")
return call_llm(user_question, model=model)
成本对比：
| 模型 | 速度 | 成本（每1K tokens） | 适用场景 |
|---|---|---|---|
| GPT-3.5-turbo | 快 | $0.0005 | 简单问答、分类 |
| GPT-4o-mini | 中 | $0.00015 | 一般任务 |
| GPT-4o | 慢 | $0.0025 | 复杂推理、创作 |
节省效果：
- 60%简单问题用GPT-3.5
- 30%中等问题用GPT-4o-mini
- 10%复杂问题用GPT-4o
- 总体成本降低：60-70%
策略B：模型蒸馏与量化
# 使用本地小模型处理简单任务
from transformers import AutoModelForCausalLM, AutoTokenizer
class LocalModelHandler:
"""本地小模型处理器"""
def __init__(self, model_name="Qwen/Qwen2-1.5B-Instruct"):
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map="auto", # 自动使用GPU
torch_dtype="auto"
)
def generate(self, prompt: str, max_length=200) -> str:
"""生成本地模型回答"""
inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
outputs = self.model.generate(
**inputs,
max_length=max_length,
temperature=0.3,
do_sample=True
)
response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
return response
# 混合架构
class HybridAgent:
"""混合Agent：本地+云端"""
def __init__(self):
self.local_model = LocalModelHandler()
self.cloud_api = CloudAPIHandler() # 云端大模型
def query(self, user_question: str) -> str:
# 简单问题用本地模型（快、免费）
if self._is_simple(user_question):
return self.local_model.generate(user_question)
# 复杂问题用云端模型（智能）
else:
return self.cloud_api.query(user_question)
优势：
- ✅ 简单问题零成本
- ✅ 响应速度快（<100ms）
- ✅ 数据隐私保护好
模型优化对比
| 策略 | 成本降低 | 速度提升 | 实现难度 |
|---|---|---|---|
| 分级模型 | 60-70% | 2-3倍 | ⭐⭐ |
| 本地小模型 | 80-90% | 5-10倍 | ⭐⭐⭐ |
| 模型量化 | 50% | 2-3倍 | ⭐⭐⭐⭐ |
📊 综合优化效果
优化前后对比
import time
import statistics
def benchmark_performance():
"""性能基准测试"""
test_queries = [
"什么是AI？",
"Python有哪些优点？",
"如何学习编程？",
# ... 更多测试用例
] * 10 # 100个测试查询
# 优化前
print("📊 优化前性能测试...")
times_before = []
for query in test_queries[:10]:
start = time.time()
response = call_llm_naive(query) # 原始实现
times_before.append(time.time() - start)
avg_before = statistics.mean(times_before)
p95_before = sorted(times_before)[int(len(times_before) * 0.95)]
print(f"平均响应时间: {avg_before*1000:.0f}ms")
print(f"P95响应时间: {p95_before*1000:.0f}ms")
# 优化后
print("\n📊 优化后性能测试...")
times_after = []
for query in test_queries[:10]:
start = time.time()
response = call_llm_optimized(query) # 优化实现
times_after.append(time.time() - start)
avg_after = statistics.mean(times_after)
p95_after = sorted(times_after)[int(len(times_after) * 0.95)]
print(f"平均响应时间: {avg_after*1000:.0f}ms")
print(f"P95响应时间: {p95_after*1000:.0f}ms")
# 提升倍数
print(f"\n🚀 性能提升:")
print(f"平均响应时间: {avg_before/avg_after:.1f}x")
print(f"P95响应时间: {p95_before/p95_after:.1f}x")
benchmark_performance()
典型结果：
| 指标 | 优化前 | 优化后 | 提升 |
|---|---|---|---|
| 平均响应时间 | 3500ms | 350ms | 10x |
| P95响应时间 | 8000ms | 800ms | 10x |
| 并发QPS | 10 | 100+ | 10x+ |
| API成本/天 | ¥100 | ¥20 | 降低80% |
🛠️ 完整优化项目
我已经为你准备了完整的性能优化工具包：
GitHub仓库：
git clone https://github.com/Lee985-cmd/AI-30-Day-Challenge.git
cd projects/agent-performance-optimizer
项目包含：
- ✅ 多层缓存实现（内存、Redis、语义）
- ✅ 异步处理框架
- ✅ 批处理器
- ✅ 智能模型选择器
- ✅ 性能监控Dashboard
- ✅ 基准测试工具
快速开始：
# 安装依赖
pip install -r requirements.txt
# 启动Redis（可选，用于分布式缓存）
docker run -d -p 6379:6379 redis
# 运行性能测试
python benchmark.py
# 启动监控面板
streamlit run dashboard.py
💡 最佳实践总结
优化优先级
-
第一步：添加缓存（投入产出比最高）
- 先上内存缓存
- 再上Redis
- 最后考虑语义缓存
-
第二步：异步化
- IO密集型用asyncio
- CPU密集型用多线程
- 大规模用消息队列
-
第三步：批处理
- 合并小请求
- 使用流式响应
-
第四步：模型优化
- 分级使用模型
- 考虑本地小模型
监控指标
必须监控的指标：
- 平均响应时间
- P95/P99响应时间
- 缓存命中率
- API调用次数
- 错误率
推荐工具：
- Prometheus + Grafana
- ELK Stack（日志分析）
- Sentry（错误追踪）
❓ 常见问题
Q1: 缓存一致性如何保证？
答：
- 设置合理的TTL（过期时间）
- 数据更新时主动清除相关缓存
- 使用版本号机制
def update_knowledge_base(new_data: dict):
"""更新知识库时清除缓存"""
# 1. 更新数据库
db.update(new_data)
# 2. 清除相关缓存
cache.clear_pattern("rag:*")
semantic_cache.clear()
# 3. 记录日志
logger.info("知识库已更新，缓存已清除")
Q2: 如何处理缓存穿透？
答：
- 使用布隆过滤器预判
- 空值也缓存（短TTL）
- 互斥锁防止并发请求
from threading import Lock
lock = Lock()
def query_with_lock(query: str) -> str:
cached = cache.get(query)
if cached:
return cached
with lock: # 互斥锁
# 双重检查
cached = cache.get(query)
if cached:
return cached
# 调用LLM
response = call_llm(query)
cache.set(query, response)
return response
Q3: 异步处理的错误如何捕获？
答：
- 使用try-except包裹
- 设置超时时间
- 实现重试机制
async def safe_call_llm(prompt: str, retries=3) -> str:
"""安全的LLM调用"""
for attempt in range(retries):
try:
result = await call_llm_async(prompt)
return result
except Exception as e:
if attempt == retries - 1:
raise
wait_time = 2 ** attempt # 指数退避
await asyncio.sleep(wait_time)
📚 延伸阅读
🎯 总结
核心要点：
- ✅ 缓存是第一道防线 - 能解决50-80%的性能问题
- ✅ 异步化提升并发能力 - 从10 QPS到100+ QPS
- ✅ 批处理降低成本 - API费用降低60-80%
- ✅ 智能模型选型 - 在保证质量的前提下降低成本
行动建议：
- 先从缓存开始（最简单、效果最好）
- 逐步引入异步处理
- 实施批处理优化
- 最后优化模型层
预期效果：
- 响应时间：从秒级到毫秒级
- 并发能力：提升10倍+
- 运营成本：降低80%
完整代码和项目： 👉 GitHub仓库
扫一扫
378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
