哪些函数应该是异步的（置于Node.js中）？

Question

My knowledge of the subject is quite low in general, so please bear with me.

I understand that functions that might require an extra delay, like database read/writes, file reads, etc. should be run asynchronously, so as to not block.

What hasn't really been answered after my searches is:

Should something like a simple for-loop be run asynchronously? It could be something as simple as:

function a() {
    var a = 0;  
    for(i=0; i<10000000; i++) {
        a++;
    };
};

Since something like this could take a few milliseconds, should it be put inside a Node.js promise?

Am I correct to assume that if I don't, then yes there will be blocking, albeit for just a few milliseconds?

Answer 1

I'm not sure if I understand you correctly, but I don't think that will work as you expect. "Wrapping" that function inside a future will make the call asynchronous but not the function itself.

Suppose the following scenario:

f1();
a();
f2();
f3();
// (...)

if a() is synchronous f2() will only be executed after a() finishes (ie your for loop). Now if a() is asynchronous this means that f2() will be executed right away, so it does not block execution.

But as NodeJS is single-threaded and all code is executed in a loop, whenever that for loop gets executed it will be run from start to finish (from iteration 0 to 9999999) without pauses, so it will block other operations during that time.

So using promises you are only delaying when that code will block you app.

If that function only takes some milliseconds to complete that may not make a lot of difference. But if it takes seconds or minutes for example, you would need to make sure that task gives back control to NodeJS from time to time using nextTick or using something like async.eachSeries .

This article explains this is some detail.

Answer 2

Since something like this could take a few milliseconds, should it be put inside a Node.js promise?

Ideally, yes. Node, or rather the V8 engine in general, is designed for high throughput/scalability therefore anything that will effectively block execution should be run asynchronously.

Answer 3

There is a difference between "being run asynchronously" and "being written for asynchronous-ity".

Like you mentioned, NodeJS is blocking when it runs a loop. That means nothing else will run on the CPU. It does not matter where that function is called, it will use all the CPU cycles until it finishes.

If you run it asynchronously, via a Promise or the async library, whenever the for-loop runs, it will run forever until it is done. Nothing else will run at this time, it will block all other actions. If you write it for asynchronous-ity, you would break down the loop into smaller chunks, that would be run asynchronously in series or parallel, each chunk being small enough to not seriously impact other things that are happening.

Is a few milliseconds too much? Depends on your app. The thing is, the processing will have to happen sometime, so there is no point in breaking it down too much. Just be aware that a loop (and some other constructs, like Array.forEach ) are blocking your other events from processing, do your best to avoid problems, and test your app the best you can.

Answer 4

Nodejs is different from most other programming environments in that all users of a web app share the same thread. That means if one user is requesting information from the database, you do not want all the other users to wait in line for the database request to be complete before processing, say some other user's request for a page load. Hence, it is a good idea, as much as is possible, to free up the thread so Node can serve other user requests.

Now what does free up the thread mean? Essentially, the V8 engine (underpinning nodejs) executes commands in a step-by-step manner, as most programmers are used to. However, it is possible that the execution thread reaches a point where it is waiting for input from another source. If the function is written in an synchronous manner, the execution simply waits there until the input is received and then continues to process the rest of the program. However, if the function is written in a non-blocking (asynchronous) manner, the thread is freed up to execute any other functions that are available (eg new requests from other users). Writing your code in a non-blocking mode makes the execution much more efficient in a multi-user environment.

Now for your specific issue, the question to ask is if you make the function, a(), asynchronous, would you be freeing up the execution thread? The answer is NO. This is because node is still executing the for loop and so no other functions can be executed at the same time and there is no point at which node execution is suspended waiting for another system to provide input. So, no do not make your for loops asynchronous. It just adds complexity to your code and provides no value to the execution effectiveness. Instead, just try to make sure the for loops are executed as efficiently as possible.