内存泄漏与资源管理

内存泄漏的基本概念

内存泄漏指程序在运行过程中未能正确释放不再使用的内存，导致可用内存逐渐减少。这种现象在长时间运行的应用程序中尤为明显，最终可能导致性能下降甚至崩溃。内存泄漏通常由开发者疏忽引起，比如忘记释放分配的资源或保留不必要的引用。

// 典型的内存泄漏示例
function createLeak() {
  const hugeArray = new Array(1000000).fill('*');
  document.getElementById('leakButton').addEventListener('click', () => {
    console.log(hugeArray.length); // 闭包保留了hugeArray引用
  });
}

常见的内存泄漏场景

未清理的事件监听器

事件监听器如果没有正确移除，会阻止相关DOM元素被垃圾回收。特别是在单页应用中，频繁挂载/卸载组件时容易发生这种情况。

class Component {
  constructor() {
    this.handleClick = this.handleClick.bind(this);
    document.addEventListener('click', this.handleClick);
  }
  
  handleClick() {
    console.log('Clicked');
  }
  
  // 忘记移除监听器
  // removeListeners() {
  //   document.removeEventListener('click', this.handleClick);
  // }
}

定时器未清除

setInterval和setTimeout如果不及时清理，会持续占用内存。即使回调函数已经不再需要执行，定时器仍然会保持对函数及其闭包作用域的引用。

function startPolling() {
  setInterval(() => {
    fetchData().then(data => {
      updateUI(data);
    });
  }, 5000);
}

// 应该提供停止轮询的方法
// let pollingId = startPolling();
// clearInterval(pollingId);

Mongoose中的内存管理

连接池管理

Mongoose使用连接池来管理数据库连接。如果不正确关闭连接，会导致连接泄漏，最终耗尽连接池资源。

const mongoose = require('mongoose');

async function connectDB() {
  try {
    await mongoose.connect('mongodb://localhost/test', {
      poolSize: 5, // 连接池大小
      useNewUrlParser: true
    });
  } catch (err) {
    console.error('Connection error', err);
  }
}

// 应用关闭时应断开连接
// process.on('SIGINT', () => mongoose.disconnect());

查询结果缓存

Mongoose会缓存查询结果以提高性能。对于大型数据集，这可能导致内存占用过高。

const bigSchema = new mongoose.Schema({/*...*/});
const BigModel = mongoose.model('Big', bigSchema);

// 处理大数据集时应使用流或分批查询
BigModel.find({}).cursor().on('data', (doc) => {
  // 逐条处理文档
}).on('end', () => {
  // 处理完成
});

前端框架中的资源管理

React组件卸载清理

React组件卸载时需要清理副作用，包括事件监听器、订阅和定时器等。

useEffect(() => {
  const timer = setInterval(() => {
    // 某些操作
  }, 1000);

  return () => {
    clearInterval(timer); // 清理定时器
  };
}, []);

Vue的beforeDestroy钩子

Vue组件应在销毁前清理资源，避免内存泄漏。

export default {
  data() {
    return {
      observer: null
    };
  },
  mounted() {
    this.observer = new MutationObserver(callback);
    this.observer.observe(targetNode, config);
  },
  beforeDestroy() {
    this.observer.disconnect(); // 清理观察者
  }
};

工具与检测方法

Chrome DevTools内存分析

使用Chrome开发者工具可以检测内存泄漏：

1. 打开Performance面板记录内存变化
2. 使用Memory面板拍摄堆快照
3. 比较多个快照查找泄漏对象

Node.js内存监控

Node.js应用可以使用以下工具监控内存：

• process.memoryUsage() API
• --inspect标志配合Chrome DevTools
• heapdump模块生成堆转储文件

setInterval(() => {
  const memory = process.memoryUsage();
  console.log(`RSS: ${memory.rss / 1024 / 1024} MB`);
}, 5000);

最佳实践与预防措施

资源获取即初始化(RAII)

采用RAII模式确保资源在使用完毕后自动释放。

class ResourceHolder {
  constructor() {
    this.resource = acquireResource();
  }
  
  dispose() {
    releaseResource(this.resource);
  }
}

// 使用try-finally确保释放
const holder = new ResourceHolder();
try {
  // 使用资源
} finally {
  holder.dispose();
}

弱引用与WeakMap

使用弱引用避免无意中保持对象存活。

const weakMap = new WeakMap();
let key = { id: 1 };
weakMap.set(key, 'some data');

// 当key不再被引用时，条目会自动从WeakMap中删除
key = null;

自动化测试

编写内存泄漏检测测试，定期运行确保代码质量。

describe('Memory Leak Tests', () => {
  it('should not leak event listeners', async () => {
    const instance = new EventEmitter();
    const listenerCount = () => instance.listenerCount('event');
    
    const initial = listenerCount();
    const listener = () => {};
    instance.on('event', listener);
    instance.off('event', listener);
    
    expect(listenerCount()).to.equal(initial);
  });
});

性能优化与权衡

缓存策略

合理使用缓存可以减少内存占用，但需要设置适当的失效机制。

const cache = new Map();

function getCachedData(key) {
  if (cache.has(key)) {
    const { data, timestamp } = cache.get(key);
    if (Date.now() - timestamp < 60000) { // 1分钟缓存
      return data;
    }
  }
  const freshData = fetchData(key);
  cache.set(key, { data: freshData, timestamp: Date.now() });
  return freshData;
}

分批处理大数据

处理大型数据集时应避免一次性加载全部数据。

async function processLargeDataset(datasetId) {
  let skip = 0;
  const limit = 100;
  let hasMore = true;
  
  while (hasMore) {
    const batch = await fetchBatch(datasetId, skip, limit);
    processBatch(batch);
    skip += limit;
    hasMore = batch.length === limit;
  }
}