内存泄漏检测与预防

内存泄漏的基本概念

内存泄漏指的是程序中已分配的内存未能被正确释放，导致可用内存逐渐减少。在Koa2应用中，内存泄漏可能由未清理的定时器、未关闭的数据库连接、未解绑的事件监听器等引起。长期运行的服务端应用尤其需要注意内存泄漏问题，因为累积的泄漏最终可能导致进程崩溃。

// 典型的内存泄漏示例：未清除的定时器
const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  const timer = setInterval(() => {
    console.log('Leaking timer...');
  }, 1000);
  
  ctx.body = 'Hello World';
  // 忘记清除定时器
});

常见的内存泄漏场景

未清理的定时器和回调

定时器是最常见的内存泄漏来源之一。在Koa2中间件中创建的setInterval或setTimeout如果不及时清理，会持续占用内存。即使客户端已经断开连接，这些定时器仍然会继续执行。

app.use(async ctx => {
  const timer = setTimeout(() => {
    console.log('This should be cleaned up');
  }, 5000);
  
  // 正确的做法是使用ctx.req.on('close')来清理
  ctx.req.on('close', () => {
    clearTimeout(timer);
  });
  
  ctx.body = 'Response with cleanup';
});

未解绑的事件监听器

在Koa2应用中添加事件监听器后，如果不及时移除，相关对象就无法被垃圾回收。特别是在单例对象上添加监听器时更需要注意。

const EventEmitter = require('events');
const emitter = new EventEmitter();

app.use(async ctx => {
  const handler = () => console.log('Event handled');
  emitter.on('someEvent', handler);
  
  // 应该在适当的时候移除监听器
  ctx.res.on('close', () => {
    emitter.off('someEvent', handler);
  });
});

内存泄漏检测工具

Node.js内置工具

Node.js提供了多种内存分析工具，最常用的是--inspect标志和Chrome DevTools的结合使用。

1. 启动应用时添加--inspect标志：

node --inspect your-koa-app.js

2. 打开Chrome浏览器，访问chrome://inspect
3. 点击对应的Node.js进程进行调试
4. 在Memory标签页中可以创建堆快照(Heap Snapshot)进行分析

heapdump模块

heapdump模块可以在运行时生成堆内存快照，便于分析内存使用情况。

const heapdump = require('heapdump');

// 在内存使用量高时手动生成快照
process.on('SIGUSR2', () => {
  const filename = `/tmp/heapdump-${process.pid}-${Date.now()}.heapsnapshot`;
  heapdump.writeSnapshot(filename);
  console.log(`Created heapdump: ${filename}`);
});

内存泄漏预防策略

资源清理中间件

在Koa2中，可以创建专门的中间件来处理资源清理工作，确保在请求结束时释放所有相关资源。

async function resourceCleanup(ctx, next) {
  const cleanupTasks = [];
  ctx.cleanup = (task) => cleanupTasks.push(task);
  
  try {
    await next();
  } finally {
    // 逆序执行所有清理任务
    while (cleanupTasks.length) {
      const task = cleanupTasks.pop();
      try {
        await task();
      } catch (err) {
        console.error('Cleanup task failed:', err);
      }
    }
  }
}

// 使用示例
app.use(resourceCleanup);
app.use(async ctx => {
  const timer = setInterval(() => {}, 1000);
  ctx.cleanup(() => clearInterval(timer));
  
  const dbConn = await getDBConnection();
  ctx.cleanup(() => dbConn.close());
});

使用WeakRef和FinalizationRegistry

ES2021引入了WeakRef和FinalizationRegistry，可以帮助管理内存但不适合作为主要的内存管理手段。

const registry = new FinalizationRegistry((heldValue) => {
  console.log(`Object ${heldValue} was garbage collected`);
});

app.use(async ctx => {
  const largeObject = createLargeObject();
  registry.register(largeObject, 'largeObject');
  
  // 使用WeakRef避免强引用
  const weakRef = new WeakRef(largeObject);
});

数据库连接池管理

数据库连接泄漏是Koa2应用中常见的问题。正确的连接池管理至关重要。

const { Pool } = require('pg');
const pool = new Pool({
  max: 20, // 最大连接数
  idleTimeoutMillis: 30000, // 空闲连接超时
  connectionTimeoutMillis: 2000 // 连接超时
});

app.use(async ctx => {
  const client = await pool.connect();
  try {
    const result = await client.query('SELECT * FROM users');
    ctx.body = result.rows;
  } finally {
    client.release(); // 确保总是释放连接
  }
});

缓存管理策略

不当的缓存实现会导致内存快速增长。应该实现大小限制和过期策略。

const LRU = require('lru-cache');

const cache = new LRU({
  max: 500, // 最大缓存项数
  maxAge: 1000 * 60 * 10 // 10分钟过期
});

app.use(async ctx => {
  const key = ctx.url;
  let data = cache.get(key);
  
  if (!data) {
    data = await fetchDataFromDB();
    cache.set(key, data);
  }
  
  ctx.body = data;
});

监控和报警系统

建立内存监控系统可以在内存泄漏变得严重之前发现问题。

const promClient = require('prom-client');

// 收集Node.js内存指标
const memoryUsage = new promClient.Gauge({
  name: 'nodejs_memory_usage_bytes',
  help: 'Node.js memory usage',
  labelNames: ['type'],
});

setInterval(() => {
  const mem = process.memoryUsage();
  memoryUsage.set({type: 'rss'}, mem.rss);
  memoryUsage.set({type: 'heapTotal'}, mem.heapTotal);
  memoryUsage.set({type: 'heapUsed'}, mem.heapUsed);
}, 5000);

// 在Koa2中暴露指标端点
app.use(async (ctx) => {
  if (ctx.path === '/metrics') {
    ctx.body = await promClient.register.metrics();
    ctx.type = promClient.register.contentType;
  }
});

压力测试和基准测试

定期进行压力测试可以帮助发现潜在的内存泄漏问题。

const autocannon = require('autocannon');

function runStressTest() {
  autocannon({
    url: 'http://localhost:3000',
    connections: 100, // 并发连接数
    duration: 60 // 测试持续时间(秒)
  }, (err, result) => {
    if (err) console.error(err);
    console.log(result);
  });
}

// 可以结合内存快照进行测试
runStressTest();
setTimeout(() => {
  heapdump.writeSnapshot('/tmp/after-stress-test.heapsnapshot');
}, 120000);

代码审查和最佳实践

建立团队代码审查规范，特别注意以下容易导致内存泄漏的模式：

1. 全局变量存储请求相关数据
2. 闭包中意外保留大对象引用
3. 未正确实现析构函数的类
4. 缓存未设置大小限制
5. 第三方库的不当使用

// 不良模式：全局变量累积数据
const requestHistory = [];

app.use(async ctx => {
  requestHistory.push({
    url: ctx.url,
    time: Date.now()
  });
  // 应该限制requestHistory的大小或定期清理
});

性能优化与内存管理的平衡

在追求性能的同时，需要注意内存使用情况。例如，流式处理大文件比完全加载到内存更安全。

const fs = require('fs');
const { pipeline } = require('stream');

app.use(async ctx => {
  ctx.set('Content-Type', 'application/octet-stream');
  
  // 使用流而不是完全读取文件
  const fileStream = fs.createReadStream('/path/to/large/file');
  await pipeline(
    fileStream,
    ctx.res
  );
});