NodeJS memory consumption in an infinite loop

Question

I don't know if this is a bug with Node or V8, but if I run the following code the node process leaks memory. The GC never seems to kick in and in a few seconds it's consuming >1GB of memory. This is unexpected behavior. Am I missing something?

Here's the code:

for(;;) { console.log(1+1); }

Obviously, this is a little bit of a contrived situation, but I can see an issue with a long-running process that would never free memory.

Edit: I tried both with v0.5.10 (unstable) and v0.4.12 (stable) and the unstable version performs a little bit better---the stable version just stops outputting to the console but continues to consume memory, whereas the stable version continues executing and consuming memory without pause.

Answer 1

You are blocking node.js event loop by never returning to it.

When you write something to a stream node.js does that asynchronously: it sends the write request, queues information about sent request in the stream's internal data-structures and awaits the callback that would notify it about the completion.

If you are blocking event loop the callback will never be called (because incoming events are never processed) and auxiliary data structures queued in the stream will never be freed.

The same can probably happen if you "overload" event loop by constantly scheduling your own events with nextTick/setInterval/setTimeout.

Answer 2

As Node.js v0.10 has been released, setImmediate should be used as the first choice instead of process.nextTick when calling the recursive callback.

function loginf() {
  console.log(1+1);
  setImmediate(loginf);
}
loginf();

The memory consumption of this chunk of code kept low ( <10MB ) after running for about 15 mins on my computer.

On the contrary, Running the infinite for loop caused memory leek and the process.nextTick throwed an Maximum call stack size exceeded error.

Check this Q&A also: setImmediate vs. nextTick

Answer 3

The answer by @VyacheslavEgorov seems right on but I would guess that deferring to the event loop would solve the problem. You might want to compare how your infinite for-loop compares to this infinite looping strategy:

function loginf() {
  console.log(1+1);
  process.nextTick(loginf);
}
loginf();

The idea is to use process.nextTick(cb) to defer to the event loop and (presumably) allow the GC to do its thing.