1

I know the title sounds like a dupe of a dozen other questions, and it may well be. However, I've read those dozen questions, and Googled around for awhile, and found nothing that answers these questions to my satisfaction.

This might be because nobody has answered it properly, in which case you should vote me up.

This might be because I'm dumb and didn't understand the other answers (much more likely), in which case you should vote me down.

Context:

I know that IO operations in Node.js are detected and made to run asynchronously by default. My question is about non-IO operations that still might block/run for a long time.

Say I have a function blockingfunction with a for loop that does addition or whatnot (pure CPU cycles, no IO), and a lot of it. It takes a minute or more to run.

Say I want this function to run whenever someone makes a certain request to my server.

Question:

Obviously, if I explicitly invoke this loop at the outer level in my code, everything will block until it completes.

Most suggestions I've read suggest pushing it off into the future by starting all of my other handlers/servers etc. first, and deferring invocation of the function via process.nextTick or setTimeout(blockingfunction, 0).

  • But won't blockingfunction1 then just block on the next spin around the execution loop? I may be wrong, but it seems like doing that would start all of my other stuff without blocking the app, but then the first time someone made the request that results in blockingfunction being called, everything would block for as long as it took to complete.

  • Does putting blockingfunction inside a setTimeout or process.nextTick call somehow make it coexist with future operations without blocking them?

  • If not, is there a way to make blockingfunction do that without rewriting it?

  • How do others handle this problem? A lot of the answers I've seen are to the tune of "just trust your CPU-intensive things to be fast, they will be", but this doesn't satisfy.

  • Absent threading (where I can be guaranteed that the execution of blockingfunction will be interleaved with the execution of whatever else is going on), should I re-write CPU-intensive/time consuming loops to use process.nextTick to perform a fixed, guaranteed-fast number of iterations per tick?

Improve this question

2 Answers 2

Reset to default
2

Yes, you are correct. If you defer your function until the next tick, it will just block in that tick rather than the current one.

Unfortunately, there is no magic here that solves this for you. While it is possible to fire up that function in another process, it might not be worth the hassle, depending on what you're doing.

I recommend re-writing your function in such a way that work happens for a bit, and then continues on the next tick. Node ticks are very efficient... you could call them every iteration of a decent sized loop if needed, without a whole ton of overhead. Of course, you would have to profile it in your code to see what the impact is.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

Yes, a blocking function will keep blocking even if you run it process.nextTick.

Some options:

  1. If it truly takes a while, then perhaps it should be spun out to a queue where you can have a dedicated worker process handle it.

    1a. Node.js has a child-process flavor specifically for forking other node.js files with a built in communication channel. So e.g. you can create one (or several) thread that handles these requests in order, then responds and hits the callback. See: http://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options

  2. You can break up the blockingFunction into chunks that run in a loop. Have it call every X iterations with process.nextTick to make way for other events to be handled.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.