Why can node have high concurrency?

Because node has "transaction-driven" and asynchronous "I/O" characteristics, it is a non-blocking asynchronous operation; for each concurrent request, the server registers a firing event for the request and gives a callback function in sequence. Execute event processing, execute the callback function after the processing is completed, and then execute the next event processing, so the node can achieve high concurrency.

The operating environment of this tutorial: windows10 system, nodejs version 12.19.0, Dell G3 computer.

Why node can have high concurrency

Nodejs is a non-blocking asynchronous operation. For each concurrent request, the server registers a firing event (I/O) for the request and gives a callback function (this process does not block new connection requests). Execute event processing (I/O) in sequence, execute the callback function after the processing is completed, and then execute the next event processing (I/O).

Before explaining why node can achieve high concurrency, we might as well understand several other features of node:

Single thread

Let’s first To clarify a concept, node is single-threaded, which is the same as JavaScript in browsers, and in node the JavaScript main thread and other threads (such as I/O threads) cannot share state.

The advantage of single thread is:

• There is no need to pay attention to the state synchronization between threads like multi-threading

• There is no overhead caused by thread switching

• There is no deadlock

Of course, single thread also has many disadvantages:

• Unable to fully utilize multi-core CPU

• A large number of calculations occupying the CPU will cause application blocking (that is, not suitable for CPU-intensive applications)

• The error will cause the entire application to exit

Asynchronous I/O

You may ask, since node is single-threaded, all events are in Processing on one thread, wouldn't it be very inefficient and contrary to high concurrency?

On the contrary, the performance of node is very high. One of the reasons is that node has an asynchronous I/O feature. Whenever an I/O request occurs, node will provide an I/O thread for the request. Then node will not care about the I/O operation process, but will continue to execute the event on the main thread. It only needs to be processed when the request returns the callback. That is to say, node saves a lot of time waiting for requests.

This is also one of the important reasons why node supports high concurrency

In fact, not only I/O operations, most operations of node are performed in this asynchronous manner. It is like an organizer. It does not need to do everything personally. It only needs to tell members how to operate correctly, accept feedback, and handle key steps, so that the entire team can run efficiently.

Transaction Driver

You may want to ask again, how does node know that the request has returned a callback, and when should it handle these callbacks?

The answer is another feature of node: transaction driver, that is, the main thread runs the program through the event loop trigger.

This is another important reason why node supports high concurrency

Recommended learning: "nodejs video tutorial"

The above is the detailed content of Why can node have high concurrency?. For more information, please follow other related articles on the PHP Chinese website!