The garbage collection mechanism

Basic Concepts of Garbage Collection Mechanism

Node.js uses the V8 engine's garbage collection mechanism to manage memory. Garbage Collection (GC) is an automatic memory management mechanism responsible for reclaiming memory occupied by objects that are no longer in use. V8's garbage collector employs a generational garbage collection strategy, dividing the heap memory into the Young Generation and the Old Generation, and uses different algorithms for each generation.

// Example: Create an object and then dereference it
let obj = { name: "example" };
obj = null; // Dereference the object, making it eligible for garbage collection

Young Generation Garbage Collection

The Young Generation stores short-lived objects and uses the Scavenge algorithm for garbage collection. The Scavenge algorithm divides the Young Generation into two equal-sized spaces: the From space and the To space. Newly created objects are first allocated to the From space. When the From space is nearly full, garbage collection is triggered:

1. Mark live objects.
2. Copy live objects to the To space.
3. Clear the From space.
4. Swap the roles of the From and To spaces.

function createObjects() {
  let temp1 = { id: 1 }; // Allocated to the Young Generation
  let temp2 = { id: 2 }; // Allocated to the Young Generation
  return temp1; // temp2 will become garbage
}

let keptObject = createObjects();
// After the function executes, temp2 will be reclaimed

Old Generation Garbage Collection

Objects that survive longer are promoted to the Old Generation. The Old Generation uses the Mark-Sweep and Mark-Compact algorithms:

1. Mark phase: Traverse the object graph and mark live objects.
2. Sweep phase: Reclaim memory occupied by unmarked objects.
3. Compact phase (optional): Defragment memory.

// Long-lived objects are promoted to the Old Generation
let persistentObject = { data: "Long-term storage" };

function createLongLivedObjects() {
  let obj = { value: "Initial value" };
  // Maintain reference via closure
  return function() {
    console.log(obj.value);
    obj.value = "Modified value";
  };
}

let keeper = createLongLivedObjects();
// obj will be promoted to the Old Generation

Incremental Marking and Lazy Sweeping

To reduce pauses caused by garbage collection, V8 introduces Incremental Marking and Lazy Sweeping:

• Incremental Marking: Breaks the marking phase into smaller steps, alternating with JavaScript execution.
• Lazy Sweeping: Delays the sweeping process and performs it in batches.

// Creating a large number of objects may trigger incremental marking
let largeArray = [];
for (let i = 0; i < 1000000; i++) {
  largeArray.push({ index: i });
  // Incremental marking may occur during this process
}

Memory Leaks and Troubleshooting

Although garbage collection automatically manages memory, improper code can still cause memory leaks:

1. Global variable references.
2. Uncleared timers.
3. Closures accidentally retaining references.
4. Unreleased event listeners.

// Memory leak example
const leaks = [];

setInterval(() => {
  leaks.push(new Array(1000).fill("leak"));
  console.log(`Leaked ${leaks.length} MB of memory`);
}, 100);

// Use the --inspect flag to start Node.js and analyze memory via Chrome DevTools

Manually Triggering Garbage Collection

Although not recommended, garbage collection can be manually triggered in certain scenarios (debugging only):

if (global.gc) {
  global.gc(); // Requires starting Node.js with the --expose-gc flag
} else {
  console.log('Garbage collection is not exposed');
}

Best Practices for Optimizing Memory Usage

1. Avoid long-term retention of large objects.
2. Dereference unneeded objects promptly.
3. Use object pools wisely.
4. Be mindful of variable capture in closures.

// Using object pools to optimize frequently created and destroyed objects
class ObjectPool {
  constructor(createFn) {
    this.createFn = createFn;
    this.pool = [];
  }

  acquire() {
    return this.pool.pop() || this.createFn();
  }

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

// Usage example
const pool = new ObjectPool(() => ({ x: 0, y: 0 }));
const obj1 = pool.acquire();
pool.release(obj1);

V8 Engine Garbage Collection Parameter Tuning

Node.js allows adjusting garbage collection behavior via startup flags:

• --max-old-space-size: Sets the Old Generation memory limit.
• --max-semi-space-size: Sets the Young Generation semi-space size.
• --trace-gc: Prints garbage collection logs.

# Start Node.js with memory parameters
node --max-old-space-size=4096 app.js

Monitoring in Real-World Applications

Monitoring memory usage is crucial for performance optimization:

// Monitor memory usage
setInterval(() => {
  const memoryUsage = process.memoryUsage();
  console.log(`
    RSS: ${(memoryUsage.rss / 1024 / 1024).toFixed(2)} MB
    HeapTotal: ${(memoryUsage.heapTotal / 1024 / 1024).toFixed(2)} MB
    HeapUsed: ${(memoryUsage.heapUsed / 1024 / 1024).toFixed(2)} MB
    External: ${(memoryUsage.external / 1024 / 1024).toFixed(2)} MB
  `);
}, 5000);

Improvements Across Node.js Versions

The V8 engine continuously optimizes garbage collection in different Node.js versions:

• Node.js 12+: Parallel garbage collection.
• Node.js 14+: Concurrent marking.
• Node.js 16+: Improved stack scanning.

// Check garbage collection features of the current V8 version
const v8 = require('v8');
console.log(v8.getHeapStatistics());