Core points

• JavaScript runtime uses single-threaded processing, which can cause bottlenecks for Node.js applications when processing multiple user requests. Multithreading helps prevent these bottlenecks.
• Node.js worker threads allow asynchronous processing on separate threads, thereby improving performance. However, they cannot handle complex objects such as database connections and must be serialized when passing to and from the worker thread.
• Node.js child process can start another application, pass data and receive results. They are not as efficient as worker threads and are more process-intensive, but can be used when relying on external processes of Node.js.
• Node.js cluster allows for forking the same process to handle load more efficiently. They can also handle restarts when instances fail and communicate between forked processes, but the code can become increasingly complex.
• Process manager and container orchestration can run multiple Node.js application instances without writing cluster code, so they are ideal for real-time servers. Containers simulate operating systems, allowing applications to run on a single device or on thousands of machines.

JavaScript runtime uses single thread processing. The engine performs only one operation at a time and must complete the execution to perform any other operation. This rarely causes problems in the browser, as a single user interacts with the application. However, the Node.js application may be processing hundreds of user requests. Multithreading can prevent bottlenecks in your application. Consider a Node.js web application where a single user can trigger a complex, 10-second JavaScript calculation. Until this calculation is complete, the application will not be able to process incoming requests from any other users. Languages ??such as PHP and Python are also single-threaded, but they usually use a multi-threaded web server that starts a new instance of the interpreter on each request. This is resource intensive, so Node.js applications usually provide their own lightweight web server. The Node.js web server runs on a single thread, but JavaScript mitigates performance issues with its non-blocking event loop. Applications can perform asynchronous operations such as files, databases, and HTTP running on other operating system threads. The event loop continues to run and can handle other JavaScript tasks while waiting for the I/O operation to complete. Unfortunately, long-running JavaScript code (such as image processing) may take up the current iteration of the event loop. This article explains how to transfer processing to another thread using the following methods: - Worker thread - Subprocess - Cluster - Process Manager - Container

Node.js worker thread

Work threads are equivalent to Web Worker in Node.js. The main thread passes the data to another script that processes it (asynchronously) on a separate thread. The main thread continues to run and runs a callback event when the worker thread completes its work.

Note that JavaScript uses its structured cloning algorithm to serialize data into strings when passing data to and from worker threads. It can contain native types such as strings, numbers, booleans, arrays, and objects - but not functions . You won't be able to pass complex objects—such as database connections—because most objects have methods that cannot be cloned. However, you can:- Read the database data asynchronously in the main thread and pass the result data to the worker thread. - Create another connection object in the worker thread. This will incur startup costs, but it may be feasible if your function requires further database queries as part of the calculation.

Node.js worker thread API conceptually resembles the Web Workers API in the browser, but there are syntax differences. Both Deno and Bun support browsers and Node.js APIs.

Work thread demonstration

The following demonstration shows a Node.js process that writes the current time to the console every second: Open the Node.js demonstration in a new browser tab. Then, start a long running dice roll calculation on the main thread. The loop completes 100 million iterations, which stops the output of time:

<code>timer process 12:33:18 PM
timer process 12:33:19 PM
timer process 12:33:20 PM
NO THREAD CALCULATION STARTED...
┌─────────┬──────────┐
│ (index) │  Values  │
├─────────┼──────────┤
│    2    │ 2776134  │
│    3    │ 5556674  │
│    4    │ 8335819  │
│    5    │ 11110893 │
│    6    │ 13887045 │
│    7    │ 16669114 │
│    8    │ 13885068 │
│    9    │ 11112704 │
│   10    │ 8332503  │
│   11    │ 5556106  │
│   12    │ 2777940  │
└─────────┴──────────┘
processing time: 2961ms
NO THREAD CALCULATION COMPLETE

timer process 12:33:24 PM
</code>

is finished, the same calculation will be started on the worker thread. When dice processing occurs, the clock continues to run:

<code>WORKER CALCULATION STARTED...
  timer process 12:33:27 PM
  timer process 12:33:28 PM
  timer process 12:33:29 PM
┌─────────┬──────────┐
│ (index) │  Values  │
├─────────┼──────────┤
│    2    │ 2778246  │
│    3    │ 5556129  │
│    4    │ 8335780  │
│    5    │ 11114930 │
│    6    │ 13889458 │
│    7    │ 16659456 │
│    8    │ 13889139 │
│    9    │ 11111219 │
│   10    │ 8331738  │
│   11    │ 5556788  │
│   12    │ 2777117  │
└─────────┴──────────┘
processing time: 2643ms
WORKER CALCULATION COMPLETE

  timer process 12:33:30 PM
</code>

The worker process is a little faster than the main thread because it can focus on a task.

...(The remaining content is omitted because the length is too long. The core idea has been summarized earlier. The subsequent content is code examples and more detailed explanations. You can selectively read the original text as needed.)

The above is the detailed content of An Introduction to Node.js Multithreading. For more information, please follow other related articles on the PHP Chinese website!