performance-review skill

---
name: performance-review
description: 性能瓶颈定位、资源评估与优化建议能力。
---

# Skill: Performance Review

专业的性能分析技能，能够识别代码性能瓶颈、评估运行效率并提供优化建议。

## 技能描述

Performance Review 技能提供深度的代码性能分析能力，包括算法复杂度分析、资源使用评估、并发性能检查和数据库查询优化。

## 核心性能分析

### 1. 算法复杂度分析
- **时间复杂度**: 分析代码执行时间随数据规模增长的趋势
- **空间复杂度**: 评估内存使用随数据规模的变化
- **大数据处理**: 识别大数据集处理的性能瓶颈
- **算法选择**: 推荐更高效的算法和数据结构

### 2. 资源使用分析
- **CPU使用率**: 检查CPU密集型操作和优化机会
- **内存占用**: 分析内存分配、使用和释放
- **I/O操作**: 评估文件读写和网络请求效率
- **缓存使用**: 检查缓存策略和命中率

### 3. 并发性能
- **线程安全**: 检查并发访问的安全性
- **锁竞争**: 分析锁的使用和竞争情况
- **异步处理**: 评估异步操作的有效性
- **并行计算**: 识别并行化的机会

### 4. 数据库性能
- **查询优化**: 分析SQL查询的执行计划
- **索引使用**: 检查索引的有效性
- **连接池**: 评估数据库连接管理
- **N+1查询**: 识别和优化关联查询

## 性能评估指标

### 响应时间
- **优秀**: < 100ms
- **良好**: 100-500ms
- **一般**: 500ms-1s
- **较差**: 1-3s
- **不可接受**: > 3s

### 吞吐量
- **Web API**: > 1000 RPS (requests per second)
- **数据处理**: > 10,000 records/second
- **文件处理**: > 100 MB/second

### 资源使用率
- **CPU使用**: < 70% (平均)
- **内存使用**: < 80% (峰值)
- **磁盘I/O**: < 80% (峰值)
- **网络带宽**: < 80% (峰值)

## 性能模式识别

### 常见性能问题

#### 1. O(n²) 复杂度
```javascript
// 性能问题代码
function findDuplicates(arr) {
  const duplicates = [];
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j]) {
        duplicates.push(arr[i]);
      }
    }
  }
  return duplicates;
}

// 优化方案 O(n)
function findDuplicatesOptimized(arr) {
  const seen = new Set();
  const duplicates = new Set();

  for (const item of arr) {
    if (seen.has(item)) {
      duplicates.add(item);
    } else {
      seen.add(item);
    }
  }

  return Array.from(duplicates);
}
```

#### 2. 频繁的DOM操作
```javascript
// 性能问题代码
function updateList(items) {
  const list = document.getElementById('list');
  list.innerHTML = ''; // 清空列表

  items.forEach(item => {
    const li = document.createElement('li');
    li.textContent = item;
    list.appendChild(li); // 频繁DOM操作
  });
}

// 优化方案
function updateListOptimized(items) {
  const list = document.getElementById('list');
  const fragment = document.createDocumentFragment();

  items.forEach(item => {
    const li = document.createElement('li');
    li.textContent = item;
    fragment.appendChild(li);
  });

  list.innerHTML = '';
  list.appendChild(fragment); // 一次性DOM操作
}
```

#### 3. 未优化的数据库查询
```javascript
// 性能问题代码 - N+1查询问题
async function getUsersWithPosts() {
  const users = await db.query('SELECT * FROM users');

  for (const user of users) {
    user.posts = await db.query(
      'SELECT * FROM posts WHERE user_id = ?',
      [user.id]
    );
  }

  return users;
}

// 优化方案 - 单次查询
async function getUsersWithPostsOptimized() {
  const result = await db.query(`
    SELECT
      u.*,
      p.id as post_id,
      p.title,
      p.content
    FROM users u
    LEFT JOIN posts p ON u.id = p.user_id
    ORDER BY u.id, p.id
  `);

  // 转换为嵌套结构
  const usersMap = new Map();
  for (const row of result) {
    if (!usersMap.has(row.id)) {
      usersMap.set(row.id, {
        id: row.id,
        name: row.name,
        email: row.email,
        posts: []
      });
    }

    if (row.post_id) {
      usersMap.get(row.id).posts.push({
        id: row.post_id,
        title: row.title,
        content: row.content
      });
    }
  }

  return Array.from(usersMap.values());
}
```

## 性能优化策略

### 1. 算法优化
- **选择合适的数据结构**: 根据操作类型选择最优数据结构
- **减少循环嵌套**: 使用查找表或哈希表减少嵌套
- **预计算和缓存**: 将重复计算的结果缓存起来
- **延迟计算**: 只在需要时进行计算

### 2. 内存优化
- **对象池模式**: 重用对象避免频繁创建和销毁
- **内存池**: 预分配内存块避免动态分配
- **垃圾回收优化**: 减少不必要的对象创建
- **内存映射**: 对大文件使用内存映射

### 3. I/O优化
- **批量操作**: 将多个小操作合并为批量操作
- **异步I/O**: 使用非阻塞I/O操作
- **连接池**: 重用数据库和网络连接
- **压缩传输**: 压缩数据减少传输量

### 4. 并发优化
- **并行计算**: 利用多核CPU进行并行处理
- **流水线处理**: 将处理过程分解为多个阶段
- **读写锁**: 使用读写锁提高并发读性能
- **无锁数据结构**: 使用原子操作和无锁数据结构

## 性能测试方法

### 基准测试
```javascript
const Benchmark = require('benchmark');

const suite = new Benchmark.Suite;

// 添加测试用例
suite
.add('Original', function() {
  findDuplicates(largeArray);
})
.add('Optimized', function() {
  findDuplicatesOptimized(largeArray);
})
.on('cycle', function(event) {
  console.log(String(event.target));
})
.on('complete', function() {
  console.log('Fastest is ' + this.filter('fastest').map('name'));
})
.run({ 'async': true });
```

### 负载测试
```javascript
// 使用Artillery进行负载测试
// artillery.yml
config:
  target: 'http://localhost:3000'
  phases:
    - duration: 60
      arrivalRate: 10
    - duration: 120
      arrivalRate: 50
    - duration: 60
      arrivalRate: 100

scenarios:
  - name: "Load test API"
    requests:
      - get:
          url: "/api/users"
      - post:
          url: "/api/users"
          json:
            name: "Test User"
            email: "[email protected]"
```

## 性能监控

### 关键性能指标(KPI)
```javascript
// 性能监控中间件
const performanceMonitor = (req, res, next) => {
  const start = Date.now();

  res.on('finish', () => {
    const duration = Date.now() - start;

    // 记录性能指标
    console.log(`${req.method} ${req.path} - ${duration}ms`);

    // 发送到监控系统
    sendMetrics({
      endpoint: req.path,
      method: req.method,
      duration: duration,
      statusCode: res.statusCode,
      timestamp: new Date().toISOString()
    });
  });

  next();
};
```

### 内存泄漏检测
```javascript
// 内存使用监控
const memoryMonitor = () => {
  const used = process.memoryUsage();

  console.log('Memory Usage:');
  for (let key in used) {
    console.log(`${key}: ${Math.round(used[key] / 1024 / 1024)} MB`);
  }
};

// 定期检查
setInterval(memoryMonitor, 30000);
```

## 性能报告模板

```markdown
# 性能分析报告

## 基本信息
- **分析范围**: 用户管理模块
- **技术栈**: Node.js, Express, MongoDB
- **数据规模**: 10万用户，100万帖子
- **测试环境**: AWS EC2 t3.large
- **分析时间**: 2024-01-15 14:00:00

## 性能概览
- **平均响应时间**: 245ms (目标: < 200ms)
- **95百分位响应时间**: 892ms (目标: < 500ms)
- **吞吐量**: 450 RPS (目标: > 1000 RPS)
- **CPU使用率**: 78% (目标: < 70%)
- **内存使用**: 1.8GB (目标: < 2GB)
- **性能评分**: 6.2/10

## 🔍 性能瓶颈分析

### 1. 数据库查询优化 (预计提升60%)
**问题**: N+1查询问题
**位置**: userService.js:45-62
**影响**: 用户列表加载缓慢

**当前实现**:
```javascript
// 执行101次数据库查询 (1次用户查询 + 100次帖子查询)
const users = await User.find();
for (const user of users) {
  user.posts = await Post.find({ userId: user.id });
}
```

**优化方案**:
```javascript
// 使用JOIN查询，只需1次数据库查询
const users = await User.aggregate([
  {
    $lookup: {
      from: 'posts',
      localField: '_id',
      foreignField: 'userId',
      as: 'posts'
    }
  }
]);
```

**预期效果**:
- 响应时间: 800ms → 320ms
- 数据库查询: 101次 → 1次
- CPU使用率: 85% → 45%

### 2. 缓存策略优化 (预计提升40%)
**问题**: 缺少有效的缓存机制
**建议**: 实施Redis缓存

**缓存策略**:
```javascript
const cache = require('redis').createClient();

async function getCachedUser(userId) {
  // 尝试从缓存获取
  const cached = await cache.get(`user:${userId}`);
  if (cached) {
    return JSON.parse(cached);
  }

  // 从数据库获取
  const user = await User.findById(userId);

  // 存入缓存 (30分钟过期)
  await cache.setex(`user:${userId}`, 1800, JSON.stringify(user));

  return user;
}
```

### 3. 算法优化 (预计提升80%)
**问题**: 用户搜索算法复杂度为O(n²)
**优化**: 使用倒排索引

**优化前后对比**:
- 搜索时间: 2.3s → 0.4s
- 内存使用: 500MB → 200MB

## 📊 性能测试结果

### 基准测试
| 操作 | 优化前 | 优化后 | 提升 |
|------|--------|--------|------|
| 用户列表 | 892ms | 245ms | 72% |
| 用户搜索 | 2300ms | 340ms | 85% |
| 用户创建 | 120ms | 85ms | 29% |
| 用户更新 | 95ms | 72ms | 24% |

### 负载测试
**并发用户**: 1000
**测试时长**: 10分钟

| 指标 | 优化前 | 优化后 | 改善 |
|------|--------|--------|------|
| 平均响应时间 | 1.2s | 0.3s | 75% |
| 错误率 | 5.2% | 0.1% | 98% |
| 吞吐量 | 234 RPS | 892 RPS | 281% |

## 🚀 实施计划

### 第一阶段 (立即实施)
1. **数据库查询优化** (2天)
   - 实施JOIN查询
   - 添加必要索引
   - 优化查询条件

2. **基础缓存** (3天)
   - 集成Redis
   - 缓存热点数据
   - 实现缓存更新策略

### 第二阶段 (本周内)
1. **搜索引擎优化** (5天)
   - 集成Elasticsearch
   - 构建倒排索引
   - 优化搜索算法

2. **CDN集成** (2天)
   - 静态资源CDN加速
   - 图片优化和压缩

### 第三阶段 (下个迭代)
1. **代码分割和懒加载**
2. **Service Worker实现**
3. **GraphQL优化**

## 📈 监控和告警

### 性能监控指标
- API响应时间 (目标: < 200ms)
- 数据库查询时间 (目标: < 100ms)
- 缓存命中率 (目标: > 80%)
- 内存使用率 (目标: < 80%)
- CPU使用率 (目标: < 70%)

### 告警规则
```yaml
alerts:
  - name: "High Response Time"
    condition: "avg_response_time > 500ms"
    duration: "5m"

  - name: "High CPU Usage"
    condition: "cpu_usage > 80%"
    duration: "10m"

  - name: "Low Cache Hit Rate"
    condition: "cache_hit_rate < 60%"
    duration: "15m"
```

## 💡 性能最佳实践

### 代码层面
1. **避免过早优化**: 先保证正确性，再优化性能
2. **测量驱动**: 基于性能测试结果进行优化
3. **关注热点**: 优先优化执行频率高的代码
4. **渐进式改进**: 持续的小改进比大规模重构更安全

### 架构层面
1. **水平扩展**: 设计支持水平扩展的架构
2. **缓存策略**: 在不同层级实施缓存
3. **异步处理**: 对耗时操作使用异步处理
4. **资源池**: 重用昂贵的资源连接

通过系统的性能分析和优化，可以显著提升应用程序的响应速度和用户体验。