How to Reduce Memory Usage in Node.js Efficiently

To reduce memory usage in Node.js, avoid keeping large objects in memory, use streams for data processing, and trigger garbage collection with --expose-gc when needed. Also, monitor memory with tools like process.memoryUsage() and optimize code to prevent memory leaks.

Syntax

Here are key Node.js features and methods to manage memory:

• process.memoryUsage(): Returns memory usage statistics.
• global.gc(): Manually triggers garbage collection (requires --expose-gc flag).
• Streams: Handle large data in chunks to avoid loading everything into memory.

javascript

console.log(process.memoryUsage());

// To enable manual GC, run Node.js with:
// node --expose-gc your_script.js

if (global.gc) {
  global.gc();
} else {
  console.log('Garbage collection is not exposed. Run node with --expose-gc');
}

Output

{ rss: 23456768, heapTotal: 5676800, heapUsed: 3456784, external: 123456 }

Example

This example shows how to use streams to read a large file without loading it all into memory, reducing memory usage.

javascript

import fs from 'fs';

const readStream = fs.createReadStream('largefile.txt', { encoding: 'utf8' });

readStream.on('data', (chunk) => {
  console.log('Received chunk of size:', chunk.length);
});

readStream.on('end', () => {
  console.log('Finished reading file');
});

Output

Received chunk of size: 65536
Received chunk of size: 65536
...
Finished reading file

Common Pitfalls

Common mistakes that increase memory usage include:

• Keeping large objects or arrays in memory unnecessarily.
• Not using streams for large data processing.
• Forgetting to remove event listeners causing memory leaks.
• Not handling asynchronous code properly, causing closures to hold memory.

Example of a memory leak by not removing listeners:

javascript

// Wrong: Adding listeners without removal
const EventEmitter = require('events');
const emitter = new EventEmitter();

function listener() {
  console.log('Event fired');
}

setInterval(() => {
  emitter.on('event', listener); // Adds listener repeatedly
  emitter.emit('event');
}, 1000);

// Right: Remove listeners to prevent leaks
// emitter.removeListener('event', listener);

Output

Event fired
Event fired
Event fired
... (memory usage grows)

Quick Reference

Summary tips to reduce memory usage in Node.js:

• Use streams for large data instead of buffers.
• Monitor memory with process.memoryUsage().
• Manually trigger garbage collection with global.gc() if needed.
• Avoid global variables holding large data.
• Remove unused event listeners to prevent leaks.

Key Takeaways

Use streams to process large data in chunks and avoid loading it all into memory.

Regularly monitor memory usage with process.memoryUsage() to detect leaks early.

Remove event listeners and avoid global large objects to prevent memory leaks.

Run Node.js with --expose-gc to manually trigger garbage collection when necessary.

Optimize asynchronous code to avoid closures holding onto memory longer than needed.