jsMiner | A Javascript Bitcoin miner | Cryptography library

...does one call get blocked until the other call completes or are they handled simultaneously.

They are accepted in parallel, assuming your requests are primarily I/O-bound (use the database, filesystem etc..) instead of CPU-bound (perform encryption, decryption, compression etc..).

Node.js offers a type of pseudo-concurrency facilitated by using an Event Loop and the programmer writing code in an Event-driven programming style (callbacks, Promises etc...), instead of creating separate threads for each request.

An oversimplification would be like this:

• Request A arrives and is put on the event queue.
• Request A requests data from the database.
• Request B arrives and is put on the event queue.
• Request B requests data from the database.
• Request B's database request arrives and request B is served with data.
• Request A's database request arrives and request A is served with data.

As you can see, Node accepts concurrent requests and serves each when necessary. It doesn't stop accepting incoming requests until another is served. It's non-blocking.

However the above scenario is a primarily I/O-bound example, where the Node.js concurrency model shines.

In contrast, if your requests are primarily CPU-bound (instead of I/O bound) then you freeze the single thread (remember Node.js is single-threaded) it runs on, requests cannot be accepted and your server "freezes" for the duration of that single request CPU computation.

...In other words, is multithreading enabled?

I assume that a lot of Node's underlying libraries (libuv for example) do use multiple threads, however the ability to directly control threads is not exposed to the user (although in theory you can write native C++ addons where you can harness multithreading).

If you're worried that you're not utilising all CPU cores, you should look into the cluster module to spin up multiple Node.js server processes. In this case the problem is taken off your hands; the O/S scheduler should, in most cases, spread the processes across available cores; this however is called multi-processing, not multithreading.