async/await understanding in node.js

Question

Have read tons of articles and docs, however this topic still not clear enough to me. Quote from one answer https://stackoverflow.com/a/46004461/630169:

As long as the code contained inside the async/await is non-blocking it won't block, for example, db calls, network calls, filesystem calls.

But if the code contained inside async/await is blocking, then it will block the entire Node.js process, for example, infinite loops, CPU intensive tasks like image processing, etc.

However, Understanding the node.js event loop says:

Of course, on the backend, there are threads and processes for DB access and process execution.

In C# it is enough to write function marked with async and call with await so .Net puts it in another thread. However, it confused me things organized differently in Node.js and async/await function still could block the main thread.

So the question is: how to write (organize) arbitrary async/await function in node.js to be sure it will run asynchronously in separate thread or process? Is there good code example? Some npm module? Also good to have it not much trickier than C# variant. Thanks!

Some function example to made it non-blocking, for example, if I want synchronous DB call to make asynchronous (non-blocking):

var Database = require('better-sqlite3');

var db = new Database('./my_db.sqlite');

async function DBRequest() {
    var row = db.prepare("SELECT * FROM table");
    return row;
};

Note: better-sqlite3 — synchronous module.

Answer 1

Well here's some example code. Decided it was a worthwhile exercise to provide it.

You can write long-running blocking code in such a way that it can yield execution time to other functions

var array = new Array(100);
function processNext(){
    if (array.length === 0) return;
    var item = array.shift(); // gets first item from array and removes it.
    process(item); // 0.5 seconds of blocking time
    setTimeout(processNext ,500); // wait 0.5 seconds and then process the next one
    // during this waiting time, other code will run on your server.
}

processNext();

Admittedly I'm a novice and this may be a very bad idea for reasons I don't know about.

Answer 2

You're really at the mercy of the library your using here - if the code is synchronous and not I/O bound then there's really not much else you can do within your Node process to make it asynchronous.

Your only real alternative is to move that code into it's own process which consequently makes it I/O bound, that way your app can wait on it and not block it's own thread.

Answer 3

My interest was not for nothing - similar questions people asked before me, as well as on stackoverflow (and here):

But what's with longish, CPU-bound tasks?

How do you avoid blocking the event loop, when the task is at hand is not I / O bound, and lasts more than a few fractions of a millisecond? You simply can not, because there's no way ... well, there was not before threads_a_gogo.

and to solve them they have already created a bunch of modules, and some, such as threads, work both in the browser and in Node.js:

• threads
• Threads à gogo
• nPool
• threadpool-js
• threadpool
• etc.

Good if someone could attach async/await to them or provide good example - that would be nice.

By the way, here's a comrade tests driven on Threads à gogo - results with threads is 40x faster than with Cluster. So single threaded idea of Node.js does not always work well.