垃圾回收机制

垃圾回收机制的基本概念

Node.js 使用 V8 引擎的垃圾回收机制来管理内存。V8 的垃圾回收器主要基于分代回收策略，将堆内存分为新生代和老生代两个区域。新生代存放存活时间较短的对象，老生代存放存活时间较长或较大的对象。这种分代设计允许 V8 针对不同特性的对象采用不同的回收算法。

// 创建一个对象，会被分配到堆内存中
const obj = { name: 'example' };

新生代使用 Scavenge 算法进行垃圾回收。该算法将新生代空间一分为二，分别为 From 空间和 To 空间。新对象首先被分配到 From 空间，当 From 空间快满时，会触发一次垃圾回收。存活的对象会被复制到 To 空间，然后清空 From 空间，最后交换 From 和 To 空间的角色。

新生代垃圾回收过程

新生代垃圾回收的具体过程如下：

1. 检查 From 空间中的对象
2. 将存活对象复制到 To 空间
3. 清空 From 空间
4. 交换 From 和 To 空间

function createObjects() {
  const temp1 = { id: 1 };  // 分配在新生代
  const temp2 = { id: 2 };  // 分配在新生代
  return temp1;  // temp1 存活，temp2 将被回收
}

const keptObject = createObjects();

如果一个对象在多次新生代垃圾回收后仍然存活，它会被晋升到老生代。晋升的条件包括：

• 对象在新生代垃圾回收中存活超过一定次数
• To 空间已经使用了超过 25%

老生代垃圾回收机制

老生代使用标记-清除（Mark-Sweep）和标记-压缩（Mark-Compact）算法。标记-清除算法分为两个阶段：

1. 标记阶段：遍历所有对象，标记存活对象
2. 清除阶段：回收未被标记的对象

// 老生代中的大对象
const largeObject = new Array(1000000).fill({ data: 'large' });

标记-压缩算法在标记-清除的基础上增加了压缩步骤，将存活对象向一端移动，然后清理边界外的内存。这种算法可以减少内存碎片，但执行时间更长。

增量标记与惰性清理

为了减少垃圾回收造成的停顿，V8 引入了增量标记（Incremental Marking）技术。它将标记过程分解为多个小步骤，与 JavaScript 执行交替进行。这样可以避免长时间的停顿。

// 增量标记期间可以继续执行代码
setInterval(() => {
  console.log('应用代码继续执行');
}, 100);

惰性清理（Lazy Sweeping）是在增量标记之后，根据需要逐步进行内存清理的技术。它允许应用在内存压力不大时延迟清理操作。

内存泄漏的常见模式

虽然 Node.js 有垃圾回收机制，但不当的代码仍可能导致内存泄漏。常见的内存泄漏模式包括：

1. 全局变量引用

// 意外的全局变量
function leak() {
  leakedVar = '这会泄漏内存'; // 没有使用 var/let/const
}

2. 闭包保持引用

function createClosure() {
  const largeData = new Array(1000000);
  return function() {
    console.log(largeData.length); // largeData 被闭包保持
  };
}

3. 定时器未清理

const interval = setInterval(() => {
  // 一些操作
}, 1000);

// 忘记 clearInterval(interval) 会导致泄漏

4. 事件监听器未移除

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

function listener() { /* ... */ }
emitter.on('event', listener);

// 忘记 emitter.off('event', listener) 会导致泄漏

监控和调试内存问题

Node.js 提供了多种工具来监控和调试内存问题：

1. 使用 process.memoryUsage()

setInterval(() => {
  const memory = process.memoryUsage();
  console.log(`RSS: ${memory.rss}, HeapTotal: ${memory.heapTotal}, HeapUsed: ${memory.heapUsed}`);
}, 5000);

2. 使用 --inspect 标志启动 Node.js 并使用 Chrome DevTools 分析堆内存

3. 使用 heapdump 模块生成堆快照

const heapdump = require('heapdump');

// 手动生成堆快照
heapdump.writeSnapshot('/tmp/' + Date.now() + '.heapsnapshot');

4. 使用 v8 模块获取垃圾回收统计信息

const v8 = require('v8');

console.log(v8.getHeapStatistics());

优化内存使用的实践

1. 及时释放不再需要的引用

let cache = {};

function processRequest(data) {
  cache[data.id] = data;
  // 处理完成后清除缓存
  setTimeout(() => {
    delete cache[data.id];
  }, 10000);
}

2. 使用对象池重用对象

class ObjectPool {
  constructor() {
    this.pool = [];
  }

  acquire() {
    return this.pool.pop() || { id: Date.now() };
  }

  release(obj) {
    this.pool.push(obj);
  }
}

3. 避免在闭包中保持大对象

// 不好的做法
function createClosure() {
  const largeData = new Array(1000000);
  return function() {
    // 使用 largeData
  };
}

// 改进做法
function createOptimizedClosure() {
  return function(largeData) {
    // 使用传入的 largeData
  };
}

4. 合理设置缓冲区大小

// 对于可能很大的数据流，限制缓冲区大小
const stream = require('stream');
const limitedStream = new stream.Transform({
  highWaterMark: 1024 * 1024 // 1MB
});

V8 垃圾回收的高级特性

V8 还提供了一些高级垃圾回收特性：

1. 并行垃圾回收：利用多核CPU并行执行部分垃圾回收工作

2. 并发垃圾回收：在主线程执行JavaScript的同时，后台线程执行部分垃圾回收工作

3. 空闲时垃圾回收：利用浏览器的空闲时段或Node.js的事件循环空闲期执行垃圾回收

// 在Node.js中可以利用setImmediate来安排非关键任务
function processLargeData(data) {
  // 立即处理关键部分
  const result = processCriticalPart(data);
  
  // 非关键处理推迟到空闲时
  setImmediate(() => {
    processNonCriticalPart(data);
  });
  
  return result;
}

不同Node.js版本中的垃圾回收改进

Node.js 的不同版本对V8引擎的升级带来了垃圾回收机制的改进：

1. Node.js 10+ 引入了并行垃圾回收，显著减少了主线程停顿时间

2. Node.js 12+ 改进了老生代内存的并行标记和压缩

3. Node.js 14+ 进一步优化了增量标记和并发标记的效率

// 可以通过process.versions查看V8版本
console.log(process.versions.v8);

处理大内存应用的策略

对于需要处理大量数据的Node.js应用，可以考虑以下策略：

1. 使用外部存储：将大数据存储在数据库或文件系统中，而不是内存中

2. 流式处理：使用流(Stream)逐步处理数据，而不是一次性加载到内存

const fs = require('fs');
const zlib = require('zlib');

fs.createReadStream('largefile.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('largefile.txt.gz'));

3. 分片处理：将大数据分成小块逐步处理

async function processInChunks(array, chunkSize, processor) {
  for (let i = 0; i < array.length; i += chunkSize) {
    const chunk = array.slice(i, i + chunkSize);
    await processor(chunk);
  }
}

4. 使用Worker线程：将内存密集型任务分流到Worker线程

const { Worker } = require('worker_threads');

function runInWorker(data) {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./processor.js', { workerData: data });
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0) reject(new Error(`Worker stopped with exit code ${code}`));
    });
  });
}