工作流 节点子线程

Today we will look into Node JS Architecture and Single Threaded Event Loop model. In our previous posts, we have discussed about Node JS Basics, Node JS Components and Node JS installation.

今天，我们将研究Node JS体系结构和单线程事件循环模型。 在之前的文章中，我们讨论了Node JS基础知识 ， Node JS组件和Node JS安装 。

节点JS架构 (Node JS Architecture)

Before starting some Node JS programming examples, it’s important to have an idea about Node JS architecture. We will discuss about “How Node JS works under-the-hood, what type of processing model it is following, How Node JS handles concurrent request with Single-Threaded model” etc. in this post.

在开始一些Node JS编程示例之前，了解Node JS体系结构很重要。 在本文中，我们将讨论“ Node JS的工作原理，其遵循的处理模型类型，Node JS如何处理单线程模型的并发请求”等内容。

节点JS单线程事件循环模型 (Node JS Single Threaded Event Loop Model)

As we have already discussed, Node JS applications uses “Single Threaded Event Loop Model” architecture to handle multiple concurrent clients.

正如我们已经讨论的那样，Node JS应用程序使用“单线程事件循环模型”体系结构来处理多个并发客户端。

There are many web application technologies like JSP, Spring MVC, ASP.NET, HTML, Ajax, jQuery etc. But all these technologies follow “Multi-Threaded Request-Response” architecture to handle multiple concurrent clients.

有许多Web应用程序技术，例如JSP，Spring MVC，ASP.NET，HTML，Ajax，jQuery等。但是所有这些技术都遵循“多线程请求-响应”架构来处理多个并发客户端。

We are already familiar with “Multi-Threaded Request-Response” architecture because it’s used by most of the web application frameworks. But why Node JS Platform has chosen different architecture to develop web applications. What is the major differences between multithreaded and single threaded event loop architecture.

我们已经熟悉“多线程请求-响应”架构，因为大多数Web应用程序框架都使用了该架构。 但是为什么Node JS Platform选择了不同的体系结构来开发Web应用程序。 多线程和单线程事件循环体系结构之间的主要区别是什么？

Any web developer can learn Node JS and develop applications very easily. However without understanding Node JS Internals, we cannot design and develop Node JS Applications very well. So before starting developing Node JS Applications, first we will learn Node JS Platform internals.

任何Web开发人员都可以学习Node JS并轻松开发应用程序。 但是，如果不了解Node JS Internals，我们就无法很好地设计和开发Node JS应用程序。 因此，在开始开发Node JS应用程序之前，首先我们将学习Node JS Platform内部。

Node JS平台 (Node JS Platform)

Node JS Platform uses “Single Threaded Event Loop” architecture to handle multiple concurrent clients. Then how it really handles concurrent client requests without using multiple threads. What is Event Loop model? We will discuss these concepts one by one.

Node JS平台使用“单线程事件循环”架构来处理多个并发客户端。 然后，它如何真正在不使用多个线程的情况下处理并发客户端请求。 什么是事件循环模型？ 我们将一一讨论这些概念。

Before discussing “Single Threaded Event Loop” architecture, first we will go through famous “Multi-Threaded Request-Response” architecture.

在讨论“单线程事件循环”架构之前，首先我们将介绍著名的“多线程请求-响应”架构。

传统的Web应用程序处理模型 (Traditional Web Application Processing Model)

Any Web Application developed without Node JS, typically follows “Multi-Threaded Request-Response” model. Simply we can call this model as Request/Response Model.

在没有Node JS的情况下开发的任何Web应用程序通常都遵循“多线程请求-响应”模型。 简单地说，我们可以将此模型称为请求/响应模型。

Client sends request to the server, then server do some processing based on clients request, prepare response and send it back to the client.

客户端将请求发送到服务器，然后服务器根据客户端的请求进行一些处理，准备响应并将其发送回客户端。

This model uses HTTP protocol. As HTTP is a Stateless Protocol, this Request/Response model is also Stateless Model. So we can call this as Request/Response Stateless Model.

该模型使用HTTP协议。 由于HTTP是无状态协议，因此此请求/响应模型也是无状态模型。 因此，我们可以将其称为“请求/响应无状态模型”。

However, this model uses Multiple Threads to handle concurrent client requests. Before discussing this model internals, first go through the diagram below.

但是，此模型使用多个线程来处理并发客户端请求。 在讨论该模型的内部原理之前，请首先浏览下图。

Request/Response Model Processing Steps:

请求/响应模型处理步骤 ：

• Clients Send request to Web Server.客户端将请求发送到Web服务器。
• Web Server internally maintains a Limited Thread pool to provide services to the Client Requests.Web Server在内部维护一个受限线程池，以为客户端请求提供服务。
• Web Server is in infinite Loop and waiting for Client Incoming RequestsWeb服务器处于无限循环中，正在等待客户端传入请求
• Web Server receives those requests.
  • Web Server pickup one Client Request
  • Pickup one Thread from Thread pool
  • Assign this Thread to Client Request
  • This Thread will take care of reading Client request, processing Client request, performing any Blocking IO Operations (if required) and preparing Response
  • This Thread sends prepared response back to the Web Server
  • Web Server in-turn sends this response to the respective Client.

  Web服务器接收那些请求。

  • Web服务器提取一个客户端请求
  • 从线程池中拾取一个线程
  • 将此线程分配给客户请求
  • 该线程将负责读取客户端请求，处理客户端请求，执行任何阻止IO操作（如果需要）并准备响应
  • 该线程将准备好的响应发送回Web服务器
  • Web服务器依次将此响应发送到相应的客户端。

Server waits in Infinite loop and performs all sub-steps as mentioned above for all n clients. That means this model creates one Thread per Client request.

服务器在无限循环中等待，并为所有n个客户端执行上述所有子步骤。 这意味着该模型为每个客户端请求创建一个线程。

If more clients requests require Blocking IO Operations, then almost all threads are busy in preparing their responses. Then remaining clients Requests should wait for longer time.

如果更多的客户端请求需要阻止IO操作，则几乎所有线程都在忙于准备其响应。 然后其余的客户请求应该等待更长的时间。

Diagram Description:

图表说明 ：

• Here “n” number of Clients Send request to Web Server. Let us assume they are accessing our Web Application concurrently.此处，“ n”个客户端向Web服务器发送请求的数量。 让我们假设他们正在同时访问我们的Web应用程序。
• Let us assume, our Clients are Client-1, Client-2… and Client-n.让我们假设，我们的客户是Client-1，Client-2…和Client-n。
• Web Server internally maintains a Limited Thread pool. Let us assume “m” number of Threads in Thread pool.Web Server在内部维护一个受限线程池。 让我们假设线程池中的线程数为“ m”。
• Web Server receives those requests one by one.
  • Web Server pickup Client-1 Request-1, Pickup one Thread T-1 from Thread pool and assign this request to Thread T-1
    • Thread T-1 reads Client-1 Request-1 and process it
    • Client-1 Request-1 does not require any Blocking IO Operations
    • Thread T-1 does necessary steps and prepares Response-1 and send it back to the Server
    • Web Server in-turn send this Response-1 to the Client-1
  • Web Server pickup another Client-2 Request-2, Pickup one Thread T-2 from Thread pool and assign this request to Thread T-2
    • Thread T-2 reads Client-1 Request-2 and process it
    • Client-1 Request-2 does not require any Blocking IO Operations
    • Thread T-2 does necessary steps and prepares Response-2 and send it back to the Server
    • Web Server in-turn send this Response-2 to the Client-2
  • Web Server pickup another Client-n Request-n, Pickup one Thread T-n from Thread pool and assign this request to Thread T-n
    • Thread T-n reads Client-n Request-n and process it
    • Client-n Request-n require heavy Blocking IO and computation Operations
    • Thread T-n takes more time to interact with external systems, does necessary steps and prepares Response-n and send it back to the Server
    • Web Server in-turn send this Response-n to the Client-n

  If “n” is greater than “m” (Most of the times, its true), then server assigns Threads to Client Requests up to available Threads. After all m Threads are utilized, then remaining Client’s Request should wait in the Queue until some of the busy Threads finish their Request-Processing Job and free to pick up next Request.

  If those threads are busy with Blocking IO Tasks (For example, interacting with Database, file system, JMS Queue, external services etc.) for longer time, then remaining clients should wait longer time.

  • Web服务器拾取客户端-1请求-1，从线程池中拾取一个线程T-1，并将此请求分配给线程T-1
    • 线程T-1读取Client-1 Request-1并对其进行处理
    • 客户端1请求1不需要任何阻塞IO操作
    • 线程T-1执行必要的步骤并准备Response-1，并将其发送回服务器
    • Web服务器依次将此响应1发送到客户端1
  • Web服务器拾取另一个Client-2 Request-2，从线程池中拾取一个线程T-2，并将此请求分配给线程T-2
    • 线程T-2读取Client-1 Request-2并对其进行处理
    • 客户端1请求2不需要任何阻塞IO操作
    • 线程T-2执行必要的步骤并准备Response-2，并将其发送回服务器
    • Web服务器依次将此响应2发送到客户端2
  • Web服务器拾取另一个Client-n Request-n，从线程池中拾取一个线程Tn，并将此请求分配给线程Tn
    • 线程Tn读取Client-n Request-n并对其进行处理
    • 客户端n请求n需要大量的阻塞IO和计算操作
    • 线程Tn需要更多时间与外部系统进行交互，执行必要的步骤并准备Response-n并将其发送回服务器
    • Web服务器依次将此响应-n发送给客户端-n

  如果“ n”大于“ m”（大多数情况下为true），则服务器将线程分配给客户端请求，直到可用线程为止。 在使用完所有m个线程之后，其余的客户请求应在队列中等待，直到一些繁忙的线程完成其请求处理作业并可以自由接听下一个请求。

  如果这些线程忙于阻塞IO任务（例如，与数据库，文件系统，JMS队列，外部服务等进行交互）的时间更长，则其余客户端应等待更长的时间。

• Once Threads are free in Thread Pool and available for next tasks, Server pickup those threads and assign them to remaining Client Requests.一旦线程在线程池中可用并且可用于下一个任务，服务器就会拾取这些线程并将其分配给其余的客户端请求。
• Each Thread utilizes many resources like memory etc. So before going those Threads from busy state to waiting state, they should release all acquired resources.每个线程利用许多资源，如内存等。因此，在将这些线程从繁忙状态转换为等待状态之前，它们应释放所有获取的资源。

Drawbacks of Request/Response Stateless Model:

请求/响应无状态模型的缺点 ：

• Handling more and more concurrent client’s request is bit tough.处理越来越多的并发客户的请求有点困难。
• When Concurrent client requests increases, then it should use more and more threads, finally they eat up more memory.当并发客户端请求增加时，它应该使用越来越多的线程，最终它们会消耗更多的内存。
• Sometimes, Client’s Request should wait for available threads to process their requests.有时，客户的请求应等待可用线程处理其请求。
• Wastes time in processing Blocking IO Tasks.浪费时间处理阻塞IO任务。

节点JS体系结构–单线程事件循环 (Node JS Architecture – Single Threaded Event Loop)

Node JS Platform does not follow Request/Response Multi-Threaded Stateless Model. It follows Single Threaded with Event Loop Model. Node JS Processing model mainly based on Javascript Event based model with Javascript callback mechanism.

Node JS平台未遵循请求/响应多线程无状态模型。 它遵循单线程事件循环模型。 Node JS Processing模型主要基于Java事件基于Java回调机制的模型。

You should have some good knowledge about how Javascript events and callback mechanism works. If you don’t know, Please go through those posts or tutorials first and get some idea before moving to the next step in this post.

您应该对Javascript事件和回调机制的工作原理有一定的了解。 如果您不知道，请先阅读这些帖子或教程，并有所了解，然后再继续进行本文的下一步。

As Node JS follows this architecture, it can handle more and more concurrent client requests very easily. Before discussing this model internals, first go through the diagram below.

由于Node JS遵循此架构，因此可以非常轻松地处理越来越多的并发客户端请求。 在讨论该模型的内部原理之前，请首先浏览下图。

I tried to design this diagram to explain each and every point of Node JS Internals.

我试图设计该图来解释Node JS Internals的每个方面。

The main heart of Node JS Processing model is “Event Loop”. If we understand this, then it is very easy to understand the Node JS Internals.

Node JS处理模型的主要核心是“事件循环”。 如果我们理解这一点，那么很容易理解Node JS Internals。

Single Threaded Event Loop Model Processing Steps:

单线程事件循环模型处理步骤 ：

• Clients Send request to Web Server.客户端将请求发送到Web服务器。
• Node JS Web Server internally maintains a Limited Thread pool to provide services to the Client Requests.节点JS Web服务器在内部维护一个有限线程池，以为客户端请求提供服务。
• Node JS Web Server receives those requests and places them into a Queue. It is known as “Event Queue”.Node JS Web Server接收这些请求并将它们放入队列。 它被称为“事件队列”。
• Node JS Web Server internally has a Component, known as “Event Loop”. Why it got this name is that it uses indefinite loop to receive requests and process them. (See some Java Pseudo code to understand this below).Node JS Web服务器在内部具有一个称为“事件循环”的组件。 之所以获得此名称，是因为它使用无限循环来接收请求并对其进行处理。 （请参阅下面的一些Java Pseudo代码以了解这一点）。
• Event Loop uses Single Thread only. It is main heart of Node JS Platform Processing Model.事件循环仅使用单线程。 它是Node JS平台处理模型的主要核心。
• Even Loop checks any Client Request is placed in Event Queue. If no, then wait for incoming requests for indefinitely.甚至循环检查任何客户端请求是否放置在事件队列中。 如果否，则无限期等待传入的请求。
• If yes, then pick up one Client Request from Event Queue
  • Starts process that Client Request
  • If that Client Request Does Not requires any Blocking IO Operations, then process everything, prepare response and send it back to client.
  • If that Client Request requires some Blocking IO Operations like interacting with Database, File System, External Services then it will follow different approach
    • Checks Threads availability from Internal Thread Pool
    • Picks up one Thread and assign this Client Request to that thread.
    • That Thread is responsible for taking that request, process it, perform Blocking IO operations, prepare response and send it back to the Event Loop
    • Event Loop in turn, sends that Response to the respective Client.

  如果是，则从事件队列中选择一个客户端请求

  • 开始客户要求的流程
  • 如果该客户端请求不需要任何阻塞IO操作，则处理所有内容，准备响应并将其发送回客户端。
  • 如果该客户请求需要某些阻止IO操作（例如与数据库，文件系统，外部服务进行交互），则它将采用不同的方法
    • 从内部线程池检查线程可用性
    • 拾取一个线程并将此客户请求分配给该线程。
    • 该线程负责处理该请求，处理该请求，执行阻塞IO操作，准备响应并将其发送回事件循环
    • 事件循环依次将响应发送给相应的客户端。

Diagram Description:

图表说明 ：

• Here “n” number of Clients Send request to Web Server. Let us assume they are accessing our Web Application concurrently.此处，“ n”个客户端向Web服务器发送请求的数量。 让我们假设他们正在同时访问我们的Web应用程序。
• Let us assume, our Clients are Client-1, Client-2… and Client-n.让我们假设，我们的客户是Client-1，Client-2…和Client-n。
• Web Server internally maintains a Limited Thread pool. Let us assume “m” number of Threads in Thread pool.Web Server在内部维护一个受限线程池。 让我们假设线程池中的线程数为“ m”。
• Node JS Web Server receives Client-1, Client-2… and Client-n Requests and places them in the Event Queue.节点JS Web服务器接收Client-1，Client-2…和Client-n请求，并将它们放置在事件队列中。
• Node JS Even Loop Picks up those requests one by one.
  • Even Loop pickups Client-1 Request-1
    • Checks whether Client-1 Request-1 does require any Blocking IO Operations or takes more time for complex computation tasks.
    • As this request is simple computation and Non-Blocking IO task, it does not require separate Thread to process it.
    • Event Loop process all steps provided in that Client-1 Request-1 Operation (Here Operations means Java Script’s functions) and prepares Response-1
    • Event Loop sends Response-1 to Client-1
  • Even Loop pickups Client-2 Request-2
    • Checks whether Client-2 Request-2does require any Blocking IO Operations or takes more time for complex computation tasks.
    • As this request is simple computation and Non-Blocking IO task, it does not require separate Thread to process it.
    • Event Loop process all steps provided in that Client-2 Request-2 Operation and prepares Response-2
    • Event Loop sends Response-2 to Client-2
  • Even Loop pickups Client-n Request-n
    • Checks whether Client-n Request-n does require any Blocking IO Operations or takes more time for complex computation tasks.
    • As this request is very complex computation or Blocking IO task, Even Loop does not process this request.
    • Event Loop picks up Thread T-1 from Internal Thread pool and assigns this Client-n Request-n to Thread T-1
    • Thread T-1 reads and process Request-n, perform necessary Blocking IO or Computation task, and finally prepares Response-n
    • Thread T-1 sends this Response-n to Event Loop
    • Event Loop in turn, sends this Response-n to Client-n

  Node JS Even Loop逐个接管那些请求。

  • 偶数循环拾取Client-1 Request-1
    • 检查Client-1 Request-1是否确实需要任何阻塞IO操作，还是需要花费更多时间处理复杂的计算任务。
    • 由于此请求是简单的计算和无阻塞IO任务，因此它不需要单独的线程来处理它。
    • 事件循环处理该Client-1 Request-1操作（此处的操作表示Java Script的功能）中提供的所有步骤，并准备Response-1
    • 事件循环将响应1发送到客户端1
  • Even Loop拾取Client-2 Request-2
    • 检查Client-2 Request-2是否需要任何阻塞IO操作或是否需要更多时间来执行复杂的计算任务。
    • 由于此请求是简单的计算和无阻塞IO任务，因此它不需要单独的线程来处理它。
    • 事件循环处理该Client-2 Request-2操作中提供的所有步骤，并准备Response-2
    • 事件循环将响应2发送到客户端2
  • 偶数循环拾取Client-n Request-n
    • 检查Client-n Request-n是否确实需要任何阻塞IO操作或是否需要更多时间来执行复杂的计算任务。
    • 由于此请求是非常复杂的计算或阻塞IO任务，因此Even Loop不会处理此请求。
    • 事件循环从内部线程池中拾取线程T-1，并将此Client-n Request-n分配给线程T-1
    • 线程T-1读取并处理Request-n，执行必要的Blocking IO或Computation任务，最后准备Response-n
    • 线程T-1将此Response-n发送到事件循环
    • 事件循环依次将此响应-n发送给客户端-n

Here Client Request is a call to one or more Java Script Functions. Java Script Functions may call other functions or may utilize its Callback functions nature.

此处，客户端请求是对一个或多个Java脚本函数的调用。 Java脚本功能可以调用其他功能，也可以利用其回调功能的性质。

So Each Client Request looks like as shown below:

因此，每个客户请求如下所示：

For Example:

例如：

function1(function2,callback1);
function2(function3,callback2);
function3(input-params);

NOTE: –

注 ：–

• If you don’t understand how these functions are executed, then I feel you are not familiar with Java Script Functions and Callback mechanism.如果您不了解这些函数的执行方式，那么我觉得您不熟悉Java脚本函数和回调机制。
• We should have some idea about Java Script functions and Callback mechanisms. Please go through some online tutorial before starting our Node JS Application development.我们应该对Java脚本功能和回调机制有所了解。 在开始我们的Node JS应用程序开发之前，请阅读一些在线教程。

Node JS体系结构–单线程事件循环的优势 (Node JS Architecture – Single Threaded Event Loop Advantages)

1. Handling more and more concurrent client’s request is very easy.处理越来越多的并发客户端的请求非常容易。
2. Even though our Node JS Application receives more and more Concurrent client requests, there is no need of creating more and more threads, because of Event loop.即使我们的Node JS应用程序接收到越来越多的并发客户端请求，由于事件循环，也无需创建越来越多的线程。
3. Node JS application uses less Threads so that it can utilize only less resources or memoryNode JS应用程序使用更少的线程，因此只能使用更少的资源或内存

事件循环伪代码 (Event Loop Pseudo Code)

As I’m a Java Developer, I will try to explain “How Event Loop works” in Java terminology. It is not in pure Java code, I guess everyone can understand this. If you face any issues in understanding this, please drop me a comment.

作为Java开发人员，我将尝试用Java术语解释“事件循环的工作原理”。 它不是纯Java代码，我想每个人都可以理解。 如果您在理解此问题时遇到任何问题，请给我留言。

public class EventLoop {
while(true){if(Event Queue receives a JavaScript Function Call){ClientRequest request = EventQueue.getClientRequest();If(request requires BlokingIO or takes more computation time)Assign request to Thread T1ElseProcess and Prepare response}}
}

That’s all for Node JS Architecture and Node JS single threaded event loop.

这就是Node JS体系结构和Node JS单线程事件循环的全部内容。

翻译自: https://www.journaldev.com/7462/node-js-architecture-single-threaded-event-loop

工作流 节点子线程