提示工程 | | 约 23 分钟 | 8,876 字

性能优化提示词：从分析到方案

用 AI 分析性能瓶颈、生成优化方案的提示词设计

提示工程 性能 优化 分析

AI 在性能优化中的角色

性能优化是一个需要经验和直觉的领域。但 AI 可以帮我们做很多事：

  • 分析代码的时间/空间复杂度
  • 识别常见的性能反模式
  • 生成优化方案和对比
  • 解读性能分析报告
  • 推荐缓存策略和索引

我们来看一套覆盖前后端的性能优化提示词。

提示词 1：代码性能分析

你是一个性能优化专家。请分析以下代码的性能问题。

代码：
```[语言]
[代码]

运行环境：

  • 数据规模：[描述数据量]
  • 调用频率：[每秒/每分钟多少次]
  • 性能要求：[响应时间要求]

请分析：

  1. 时间复杂度（Big O）
  2. 空间复杂度
  3. 潜在的性能瓶颈
  4. 优化方案（给出优化后的代码）
  5. 优化前后的性能对比估算

### 实际示例

输入代码：

```python
def find_duplicates(users):
    """找出邮箱重复的用户"""
    duplicates = []
    for i in range(len(users)):
        for j in range(i + 1, len(users)):
            if users[i]['email'] == users[j]['email']:
                if users[i] not in duplicates:
                    duplicates.append(users[i])
                if users[j] not in duplicates:
                    duplicates.append(users[j])
    return duplicates

数据规模：users 列表有 10 万条记录

AI 分析输出：

性能分析：

1. 时间复杂度：O(n²) × O(n) = O(n³)
   - 双重循环：O(n²)
   - `not in duplicates` 检查：O(n)（列表的 in 操作是线性的）

2. 空间复杂度：O(n)

3. 瓶颈：
   - 10 万条数据，O(n³) 约需要 10^15 次操作，完全不可行
   - 列表的 `in` 操作应该用 set

4. 优化方案：

```python
def find_duplicates(users):
    """找出邮箱重复的用户 - 优化版"""
    # O(n) 时间复杂度
    email_groups = {}

    for user in users:
        email = user['email']
        if email not in email_groups:
            email_groups[email] = []
        email_groups[email].append(user)

    duplicates = []
    for email, group in email_groups.items():
        if len(group) > 1:
            duplicates.extend(group)

    return duplicates
  1. 性能对比：
    指标优化前优化后
    时间复杂度O(n³)O(n)
    10万条耗时数小时< 1 秒
    内存使用O(n)O(n)

---

## 提示词 2：数据库查询优化

请优化以下数据库查询的性能。

查询语句：

[SQL]

执行计划：

[EXPLAIN ANALYZE 输出]

表信息：

  • [表名]：[行数] 行，[大小]
  • 现有索引：[索引列表]

当前性能：[执行时间] 目标性能：[期望执行时间]

请：

  1. 分析执行计划中的瓶颈
  2. 给出优化后的 SQL
  3. 推荐需要添加的索引
  4. 如果需要，建议表结构调整
  5. 估算优化后的性能

### 常见数据库性能问题

| 问题 | 症状 | 解决方案 |
|------|------|---------|
| 全表扫描 | Seq Scan on large table | 添加合适的索引 |
| N+1 查询 | 循环中执行查询 | 使用 JOIN 或批量查询 |
| 缺少索引 | 查询慢，EXPLAIN 显示 Seq Scan | 创建索引 |
| 索引失效 | 有索引但没用上 | 检查查询条件是否匹配索引 |
| 锁竞争 | 高并发时变慢 | 优化事务范围，使用乐观锁 |
| 大量排序 | Sort 操作耗时长 | 添加覆盖排序的索引 |

### N+1 查询优化示例

原始代码（N+1 问题）：

# 1 次查询获取订单
orders = db.query("SELECT * FROM orders WHERE user_id = ?", user_id)

# N 次查询获取每个订单的商品（N+1 问题！）
for order in orders:
    order.items = db.query(
        "SELECT * FROM order_items WHERE order_id = ?", order.id
    )

优化后：

# 1 次查询获取订单
orders = db.query("SELECT * FROM orders WHERE user_id = ?", user_id)

# 1 次查询获取所有商品
order_ids = [o.id for o in orders]
all_items = db.query(
    "SELECT * FROM order_items WHERE order_id = ANY(?)", order_ids
)

# 在内存中关联
items_by_order = {}
for item in all_items:
    items_by_order.setdefault(item.order_id, []).append(item)

for order in orders:
    order.items = items_by_order.get(order.id, [])

从 N+1 次查询优化为 2 次查询。


---

## 提示词 3：前端性能优化

请分析以下前端代码的性能问题，并给出优化方案。

代码：

[代码]

页面信息：

  • 框架：[React/Vue/Angular]
  • 页面类型：[列表页/详情页/表单页]
  • 数据量：[描述]
  • 用户设备：[桌面/移动/混合]

请从以下维度分析：

  1. 渲染性能（不必要的重渲染、大列表）
  2. 网络性能（请求数量、数据大小）
  3. 资源加载（图片、字体、JS/CSS）
  4. 内存使用（内存泄漏、大对象）

### React 性能优化示例

输入代码：

```tsx
function UserList({ users, onSelect }) {
  const [search, setSearch] = useState('');

  const filteredUsers = users.filter(u =>
    u.name.toLowerCase().includes(search.toLowerCase())
  );

  return (
    <div>
      <input value={search} onChange={e => setSearch(e.target.value)} />
      {filteredUsers.map(user => (
        <UserCard
          key={user.id}
          user={user}
          onClick={() => onSelect(user.id)}
        />
      ))}
    </div>
  );
}

function UserCard({ user, onClick }) {
  return (
    <div onClick={onClick}>
      <img src={user.avatar} />
      <h3>{user.name}</h3>
      <p>{user.email}</p>
    </div>
  );
}

AI 优化输出：

问题分析：

1. 🟡 filteredUsers 每次渲染都重新计算
2. 🔴 onClick={() => onSelect(user.id)} 每次渲染创建新函数，导致 UserCard 不必要的重渲染
3. 🟡 UserCard 没有 memo，即使 props 没变也会重渲染
4. 🟡 大列表没有虚拟滚动

优化后：

```tsx
import { useState, useMemo, useCallback, memo } from 'react';
import { FixedSizeList } from 'react-window';

function UserList({ users, onSelect }) {
  const [search, setSearch] = useState('');

  // useMemo 缓存过滤结果
  const filteredUsers = useMemo(() =>
    users.filter(u =>
      u.name.toLowerCase().includes(search.toLowerCase())
    ),
    [users, search]
  );

  // useCallback 稳定回调引用
  const handleSelect = useCallback((userId: number) => {
    onSelect(userId);
  }, [onSelect]);

  // 虚拟滚动渲染函数
  const Row = useCallback(({ index, style }) => (
    <div style={style}>
      <UserCard
        user={filteredUsers[index]}
        onSelect={handleSelect}
      />
    </div>
  ), [filteredUsers, handleSelect]);

  return (
    <div>
      <input value={search} onChange={e => setSearch(e.target.value)} />
      <FixedSizeList
        height={600}
        itemCount={filteredUsers.length}
        itemSize={80}
        width="100%"
      >
        {Row}
      </FixedSizeList>
    </div>
  );
}

// memo 避免不必要的重渲染
const UserCard = memo(function UserCard({
  user,
  onSelect
}: {
  user: User;
  onSelect: (id: number) => void;
}) {
  return (
    <div onClick={() => onSelect(user.id)}>
      <img src={user.avatar} loading="lazy" />
      <h3>{user.name}</h3>
      <p>{user.email}</p>
    </div>
  );
});

优化效果：

  • useMemo：避免每次渲染重新过滤
  • memo + useCallback：减少 UserCard 不必要的重渲染
  • react-window：1000 条数据只渲染可见的 ~10 条
  • loading=“lazy”：图片懒加载

---

## 提示词 4：Bundle 分析

请分析以下 webpack/vite bundle 分析结果，给出优化建议。

Bundle 信息：

  • 总大小：[大小]
  • 主要 chunk： [chunk 列表和大小]

依赖大小排行： [依赖名和大小列表]

请：

  1. 识别过大的依赖
  2. 建议替代方案（更小的库）
  3. 建议代码分割策略
  4. 建议 Tree Shaking 优化
  5. 给出目标大小和优化路径

### 常见优化方案

| 大依赖 | 大小 | 替代方案 | 替代大小 |
|--------|------|---------|---------|
| moment.js | 290KB | dayjs | 7KB |
| lodash | 530KB | lodash-es (tree-shake) | 按需 |
| antd | 1.2MB | 按需引入 | 按需 |
| chart.js | 200KB | lightweight-charts | 40KB |

---

## 提示词 5：后端性能优化

请分析以下后端服务的性能问题。

代码：

[代码]

性能数据：

  • QPS：[当前/目标]
  • 平均响应时间：[当前/目标]
  • P99 响应时间：[当前/目标]
  • CPU 使用率：[百分比]
  • 内存使用：[大小]

请从以下维度分析：

  1. 算法和数据结构优化
  2. 缓存策略（本地缓存、Redis）
  3. 并发处理（异步、线程池）
  4. 数据库交互优化
  5. 序列化/反序列化优化

### 缓存策略提示词

请为以下接口设计缓存策略。

接口信息：

  • 端点：[URL]
  • 数据特征：[更新频率、数据大小]
  • 访问模式：[读写比、热点分布]
  • 一致性要求：[强一致/最终一致]

请设计：

  1. 缓存层级（L1 本地缓存 + L2 Redis）
  2. 缓存 Key 设计
  3. 过期策略（TTL、LRU、LFU）
  4. 缓存更新策略（Cache-Aside、Write-Through、Write-Behind）
  5. 缓存穿透/击穿/雪崩的防护
  6. 给出实现代码

#### 缓存实现示例

```python
import redis
import json
import hashlib
from functools import lru_cache
from datetime import timedelta

redis_client = redis.Redis()

class CacheService:
    """两级缓存服务"""

    def __init__(self):
        self.local_cache = {}  # L1: 本地缓存

    def get(self, key: str):
        """两级缓存读取"""
        # L1: 本地缓存
        if key in self.local_cache:
            entry = self.local_cache[key]
            if entry['expires_at'] > time.time():
                return entry['value']
            del self.local_cache[key]

        # L2: Redis
        value = redis_client.get(key)
        if value:
            data = json.loads(value)
            # 回填 L1
            self.local_cache[key] = {
                'value': data,
                'expires_at': time.time() + 60  # L1 缓存 60 秒
            }
            return data

        return None

    def set(self, key: str, value, ttl: int = 300):
        """写入两级缓存"""
        # L2: Redis
        redis_client.setex(key, ttl, json.dumps(value))
        # L1: 本地缓存
        self.local_cache[key] = {
            'value': value,
            'expires_at': time.time() + min(ttl, 60)
        }

    def invalidate(self, key: str):
        """缓存失效"""
        redis_client.delete(key)
        self.local_cache.pop(key, None)

提示词 6：负载测试分析

请分析以下负载测试结果，给出性能优化建议。

测试工具：[k6/JMeter/wrk]
测试场景：[描述]

测试结果：

[测试输出]


请分析：
1. 系统的性能拐点在哪里（QPS 多少时开始劣化）
2. 瓶颈在哪里（CPU/内存/IO/网络/数据库）
3. 错误率分析
4. 响应时间分布分析
5. 优化建议和预期效果

提示词 7：性能监控告警设计

请为以下服务设计性能监控和告警方案。

服务信息：
- 服务名：[名称]
- 技术栈：[描述]
- SLA 要求：[可用性、响应时间]

请设计：
1. 关键监控指标（RED 方法：Rate、Errors、Duration）
2. 告警阈值设置
3. 告警分级（P0-P3）
4. Grafana Dashboard 布局建议
5. 常见问题的排查 Runbook

性能优化检查清单

当你的服务性能不达标时，按这个顺序排查：

后端

  • 数据库查询是否有慢查询？（检查 slow query log）
  • 是否有 N+1 查询？
  • 是否缺少索引？
  • 是否有不必要的数据库调用？（可以缓存的数据）
  • 是否有同步阻塞操作？（可以异步化）
  • 序列化/反序列化是否高效？
  • 连接池配置是否合理？

前端

  • Bundle 大小是否合理？（目标 < 200KB gzipped）
  • 是否有不必要的重渲染？
  • 大列表是否使用虚拟滚动？
  • 图片是否优化？（WebP、懒加载、CDN）
  • 是否使用了代码分割？
  • 第三方脚本是否影响了加载？

基础设施

  • CDN 是否配置正确？
  • 压缩是否开启？（gzip/brotli）
  • HTTP/2 是否启用？
  • DNS 解析是否优化？
  • 服务器地理位置是否合理？

总结

优化层面常见问题提示词
代码层算法复杂度高提示词 1
数据库层慢查询、N+1提示词 2
前端层重渲染、大 Bundle提示词 3、4
后端层缺少缓存、同步阻塞提示词 5
系统层容量不足提示词 6

性能优化的核心原则：先测量，再优化。不要凭感觉优化，用数据说话。

过早优化是万恶之源，但过晚优化是灾难之源。用 AI 帮你快速定位瓶颈，把时间花在真正需要优化的地方。

评论

加载中...

相关文章

✨提示工程

元提示 (Meta-Prompting)：让 AI 写 Prompt

用 AI 生成和优化 Prompt，实现提示词的自动迭代

✨提示工程

Prompt 优化实战：从 60 分到 90 分

系统化的 Prompt 优化方法论：基线建立、A/B 测试、指标驱动迭代

🤖Claude Code

Claude Code 性能优化：提速与降本

减少 Token 消耗、加速响应和优化上下文管理的实用技巧

分享：

评论

加载中...