面试题：Node.js性能优化之中等难度：内存管理与优化

1. 使用V8工具检测内存泄漏

使用Chrome DevTools的Performance面板

录制性能数据：在Node.js应用运行时，打开Chrome DevTools，切换到Performance面板，点击录制按钮，然后在应用中执行可能引发内存泄漏的操作，如频繁创建对象、重复调用特定函数等。完成操作后停止录制。
分析内存增长趋势：在录制结果中，查看“Memory”图表。如果随着操作的进行，内存使用量持续上升且没有下降的趋势，这可能是内存泄漏的迹象。可以通过放大图表来更精确地观察内存变化。
查找对象分配位置：在“Call Stack”中，找到分配大量内存的函数调用。这可能是内存泄漏的源头。通过跟踪这些调用，可以确定在哪个代码片段中创建了过多未释放的对象。

使用Chrome DevTools的Memory面板

拍摄堆快照：在应用运行到特定状态时，切换到Memory面板，点击“Take Snapshot”按钮，拍摄当前堆内存的快照。可以多次拍摄快照，例如在执行某个操作前后各拍一张。
对比快照：拍摄至少两张快照后，使用“Comparison”功能。在对比结果中，查看“Delta”列，这一列显示了两张快照之间对象数量和大小的变化。关注那些新增且没有被释放的对象，这些对象可能是内存泄漏的原因。
分析对象保留树：对于可疑的对象，展开其保留树（Retained Tree）。保留树展示了对象之间的引用关系，通过分析保留树，可以找出哪些对象持有对泄漏对象的引用，从而确定内存泄漏的根源。

2. 常见内存泄漏场景及解决办法

场景一：未释放的事件监听器

描述：在Node.js中，频繁为对象添加事件监听器，但没有在不再需要时移除它们。例如，在一个HTTP服务器中，为每个请求添加事件监听器，但请求结束后监听器没有被移除。 代码示例：

const http = require('http');
const server = http.createServer((req, res) => {
    function onData() {
        // 处理数据的逻辑
    }
    req.on('data', onData);
    res.end('Hello World');
    // 没有移除data事件监听器，导致onData函数及其引用的对象无法被垃圾回收
});
server.listen(3000);

解决办法：在适当的时候移除事件监听器。例如，在请求结束时移除监听器。

const http = require('http');
const server = http.createServer((req, res) => {
    function onData() {
        // 处理数据的逻辑
    }
    req.on('data', onData);
    req.on('end', () => {
        req.removeListener('data', onData);
    });
    res.end('Hello World');
});
server.listen(3000);

场景二：闭包导致的内存泄漏

描述：当一个函数内部定义了另一个函数，并且内部函数引用了外部函数的变量时，就形成了闭包。如果闭包的生命周期过长，可能会导致外部函数的变量无法被垃圾回收，从而造成内存泄漏。 代码示例：

function outerFunction() {
    const largeObject = { /* 包含大量数据的对象 */ };
    return function innerFunction() {
        // 这里对largeObject进行操作
        console.log(largeObject.someProperty);
    };
}
const inner = outerFunction();
// inner函数持有对largeObject的引用，导致largeObject无法被垃圾回收，即使outerFunction执行完毕

解决办法：在不需要使用闭包时，及时释放对外部变量的引用。例如，在适当的时候将闭包函数设置为null。

function outerFunction() {
    const largeObject = { /* 包含大量数据的对象 */ };
    return function innerFunction() {
        // 这里对largeObject进行操作
        console.log(largeObject.someProperty);
    };
}
const inner = outerFunction();
// 在不需要inner函数时
inner = null;
// 此时largeObject可能会被垃圾回收

场景三：缓存使用不当

描述：应用中使用缓存来存储数据，如果缓存无限增长，没有合理的清理机制，就会导致内存泄漏。例如，一个简单的缓存系统，将所有请求的结果都缓存起来，随着请求的增加，缓存占用的内存越来越大。 代码示例：

const cache = {};
function getData(key) {
    if (cache[key]) {
        return cache[key];
    }
    const data = { /* 生成的数据 */ };
    cache[key] = data;
    return data;
}
// 随着调用次数增多，cache对象占用的内存会持续增长

解决办法：实现缓存清理策略，如设置缓存的最大容量，当缓存达到上限时，移除最久未使用（LRU）或最不常用（LFU）的缓存项。

class LRUCache {
    constructor(capacity) {
        this.capacity = capacity;
        this.cache = new Map();
    }
    get(key) {
        if (!this.cache.has(key)) {
            return null;
        }
        const value = this.cache.get(key);
        this.cache.delete(key);
        this.cache.set(key, value);
        return value;
    }
    put(key, value) {
        if (this.cache.has(key)) {
            this.cache.delete(key);
        }
        this.cache.set(key, value);
        if (this.cache.size > this.capacity) {
            const oldestKey = this.cache.keys().next().value;
            this.cache.delete(oldestKey);
        }
    }
}
const cache = new LRUCache(10);
function getData(key) {
    let data = cache.get(key);
    if (!data) {
        data = { /* 生成的数据 */ };
        cache.put(key, data);
    }
    return data;
}

星途面试题库