Поиск по сайту:

Архитектура Node JS — однопоточный цикл обработки событий

Сегодня мы рассмотрим архитектуру Node JS и модель однопоточного цикла событий. В наших предыдущих постах мы обсуждали установку Node JS.

JS-архитектура узла

Прежде чем приступить к некоторым примерам программирования Node JS, важно иметь представление об архитектуре Node JS. В этом посте мы обсудим «Как Node JS работает внутри, какой модели обработки он придерживается, как Node JS обрабатывает параллельный запрос с однопоточной моделью» и т. д.

Node JS Модель однопоточного цикла событий

Как мы уже обсуждали, приложения Node JS используют архитектуру «Single Threaded Event Loop Model» для работы с несколькими одновременными клиентами. Существует множество технологий веб-приложений, таких как JSP, Spring MVC, ASP.NET, HTML, Ajax, jQuery и т. д. Но все эти технологии следуют архитектуре «многопоточный запрос-ответ» для обработки нескольких одновременных клиентов. Мы уже знакомы с архитектурой «многопоточный запрос-ответ», потому что она используется в большинстве фреймворков веб-приложений. Но почему платформа Node JS выбрала другую архитектуру для разработки веб-приложений. В чем основные различия между многопоточным и однопоточным архитектура цикла событий. Любой веб-разработчик может очень легко изучить Node JS и разрабатывать приложения. Однако без понимания внутреннего устройства Node JS мы не сможем хорошо проектировать и разрабатывать приложения Node JS. Поэтому, прежде чем приступить к разработке приложений Node JS, сначала мы изучим платформу Node JS. внутренности.

Платформа узла JS

Платформа Node JS использует архитектуру «Однопоточный цикл событий» для обработки нескольких одновременных клиентов. Затем, как она на самом деле обрабатывает одновременные клиентские запросы без использования нескольких потоков. Что такое модель цикла событий? Мы обсудим эти концепции один за другим. Прежде чем обсуждать\Архитектура «Однопоточный цикл событий», сначала мы рассмотрим известную архитектуру «Многопоточный запрос-ответ».

Традиционная модель обработки веб-приложений

Любое веб-приложение, разработанное без Node JS, обычно следует модели «Многопоточный запрос-ответ». Просто мы можем назвать эту модель моделью запроса/ответа. Клиент отправляет запрос на сервер, затем сервер выполняет некоторую обработку на основе запроса клиента, подготовьте ответ и отправьте его обратно клиенту. Эта модель использует протокол HTTP. Поскольку HTTP является протоколом без сохранения состояния, эта модель запроса/ответа также является моделью без сохранения состояния. Таким образом, мы можем назвать это моделью запроса/ответа без сохранения состояния. Однако эта модель использует Несколько потоков для обработки одновременных клиентских запросов. Прежде чем обсуждать внутреннее устройство этой модели, сначала просмотрите диаграмму ниже. Этапы обработки модели запроса/ответа:

  • Клиенты отправляют запрос на веб-сервер.
  • Веб-сервер внутренне поддерживает ограниченный пул потоков для предоставления услуг клиентским запросам.
  • Веб-сервер находится в бесконечном цикле и ожидает входящих запросов от клиентов
  • Веб-сервер получает эти запросы.
    • Веб-сервер принимает один запрос клиента
    • Выбрать один поток из пула потоков
    • Назначить этот поток запросу клиента
    • Этот поток позаботится о чтении запроса клиента, обработке запроса клиента, выполнении любых блокирующих операций ввода-вывода (при необходимости) и подготовке ответа
    • Этот поток отправляет подготовленный ответ обратно на веб-сервер
    • Веб-сервер, в свою очередь, отправляет этот ответ соответствующему клиенту.

    • Здесь \n количество клиентов, отправивших запрос на веб-сервер. Предположим, что они одновременно обращаются к нашему веб-приложению.
    • Допустим, нашими Клиентами являются Клиент-1, Клиент-2… и Клиент-n.
    • Веб-сервер внутренне поддерживает ограниченный пул потоков. Предположим, что \m количество потоков в пуле потоков.
    • Веб-сервер получает эти запросы один за другим.
      • Веб-сервер получает запрос Client-1 Request-1, выбирает один поток T-1 из пула потоков и назначает этот запрос потоку T-1.
        • Поток T-1 считывает запрос Client-1 Request-1 и обрабатывает его.
        • Client-1 Request-1 не требует блокирующих операций ввода-вывода
        • Поток T-1 выполняет необходимые действия, готовит ответ-1 и отправляет его обратно на сервер
        • Веб-сервер, в свою очередь, отправляет этот ответ-1 клиенту-1

        Веб-сервер получает другой запрос Client-2 Request-2, выбирает один поток T-2 из пула потоков и назначает этот запрос потоку T-2.

        • Поток T-2 считывает запрос Client-1 Request-2 и обрабатывает его.
        • Запрос Client-1 Request-2 не требует блокировки операций ввода-вывода
        • Поток T-2 выполняет необходимые действия, подготавливает ответ 2 и отправляет его обратно на сервер.
        • Веб-сервер, в свою очередь, отправляет этот ответ-2 клиенту-2

        Веб-сервер получает другой запрос Client-n Request-n, выбирает один поток T-n из пула потоков и назначает этот запрос потоку T-n.

        • Поток T-n считывает запрос Client-n Request-n и обрабатывает его
        • Client-n Request-n требует тяжелых блокирующих операций ввода-вывода и вычислений
        • Потоку T-n требуется больше времени для взаимодействия с внешними системами, он выполняет необходимые шаги и готовит ответ-n и отправляет его обратно на сервер
        • Веб-сервер, в свою очередь, отправляет этот ответ-n клиенту-n. Если \n больше, чем \m (в большинстве случаев это правда), то сервер назначает потоки клиентским запросам до доступных потоков. . После того, как все m потоков используются, оставшийся запрос клиента должен ожидать в очереди, пока некоторые из занятых потоков не закончат свою работу по обработке запросов и не освободятся для получения следующего запроса. Если эти потоки заняты блокирующими задачами ввода-вывода (например, взаимодействием с базой данных, файловой системой, очередью JMS, внешними службами и т. д.) в течение более длительного времени, оставшиеся клиенты должны ждать дольше.

        Как только потоки освобождаются в пуле потоков и становятся доступными для следующих задач, сервер выбирает эти потоки и назначает их оставшимся клиентским запросам.

        Каждый поток использует много ресурсов, таких как память и т. д. Поэтому, прежде чем перевести эти потоки из состояния занятости в состояние ожидания, они должны освободить все полученные ресурсы.

        Недостатки модели запроса/ответа без сохранения состояния:

        • Обрабатывать все больше и больше одновременных клиентских запросов довольно сложно.
        • Когда количество одновременных клиентских запросов увеличивается, он должен использовать все больше и больше потоков, в конце концов они потребляют больше памяти.
        • Иногда клиентский запрос должен ждать, пока доступные потоки обработают свои запросы.
        • Затраты времени на обработку блокирующих задач ввода-вывода.

        Архитектура Node JS — однопоточный цикл обработки событий

        Платформа Node JS не следует многопоточной модели запроса/ответа без сохранения состояния. Это следует за однопоточной моделью с циклом событий. Модель обработки Node JS в основном основана на модели, основанной на событиях Javascript, с механизмом обратного вызова Javascript. Вы должны хорошо знать, как работают события Javascript и механизм обратного вызова. Если вы не знаете, пожалуйста, сначала просмотрите эти сообщения или руководства и получите некоторое представление, прежде чем переходить к следующему шагу в этом сообщении. Поскольку Node JS следует этой архитектуре, он может очень легко обрабатывать все больше и больше одновременных клиентских запросов. Прежде чем обсуждать внутреннее устройство этой модели, сначала просмотрите диаграмму ниже. Я попытался разработать эту диаграмму, чтобы объяснить каждый пункт внутренних компонентов Node JS. Основой модели обработки Node JS является «Цикл событий». Если мы это понимаем, то очень легко понять внутреннее устройство Node JS. Этапы обработки однопоточной модели цикла событий:

        • Клиенты отправляют запрос на веб-сервер.
        • Веб-сервер Node JS внутренне поддерживает ограниченный пул потоков для предоставления услуг клиентским запросам.
        • Веб-сервер Node JS получает эти запросы и помещает их в очередь. Она называется \Очередь событий.
        • Внутренний веб-сервер Node JS имеет компонент, известный как «Цикл событий». Причина, по которой он получил это название, заключается в том, что он использует неопределенный цикл для получения запросов и их обработки (см. некоторый псевдокод Java, чтобы понять это ниже).
        • Цикл событий использует только один поток. Это основное ядро модели обработки платформы Node JS.
        • Even Loop проверяет, помещается ли любой клиентский запрос в очередь событий. Если нет, то ждать входящих запросов неопределенное время.
        • Если да, возьмите один клиентский запрос из очереди событий.
          • Начинает обработку этого запроса клиента
          • Если этот клиентский запрос не требует блокирующих операций ввода-вывода, обработайте все, подготовьте ответ и отправьте его обратно клиенту.
          • Если этот клиентский запрос требует некоторых блокирующих операций ввода-вывода, таких как взаимодействие с базой данных, файловой системой, внешними службами, тогда он будет следовать другому подходу.
            • Проверяет доступность потоков из внутреннего пула потоков.
            • Выбирает один поток и назначает этот клиентский запрос этому потоку.
            • Этот поток отвечает за получение этого запроса, его обработку, выполнение блокирующих операций ввода-вывода, подготовку ответа и отправку его обратно в цикл обработки событий.
            • Цикл событий, в свою очередь, отправляет этот ответ соответствующему клиенту.

            • Здесь \n количество клиентов, отправивших запрос на веб-сервер. Предположим, что они одновременно обращаются к нашему веб-приложению.
            • Допустим, нашими Клиентами являются Клиент-1, Клиент-2… и Клиент-n.
            • Веб-сервер поддерживает ограниченный пул потоков. Предположим, что \m количество потоков в пуле потоков.
            • Веб-сервер Node JS получает запросы Client-1, Client-2… и Client-n и помещает их в очередь событий.
            • Четный цикл Node JS обрабатывает эти запросы один за другим.
              • Even Loop получает запрос Client-1 Request-1
                • Проверяет, требует ли Client-1 Request-1 каких-либо блокирующих операций ввода-вывода или требуется больше времени для сложных вычислительных задач.
                • Поскольку этот запрос представляет собой простое вычисление и задачу неблокирующего ввода-вывода, для его обработки не требуется отдельный поток.
                • Цикл обработки событий обрабатывает все шаги, указанные в этой операции Client-1 Request-1 (здесь операции означают функции Java Script), и подготавливает Response-1
                • Цикл событий отправляет Response-1 клиенту-1

                • Проверяет, требует ли Client-2 Request-2 каких-либо блокирующих операций ввода-вывода или требует больше времени для сложных вычислительных задач.
                • Поскольку этот запрос представляет собой простое вычисление и задачу неблокирующего ввода-вывода, для его обработки не требуется отдельный поток.
                • Цикл обработки событий обрабатывает все шаги, указанные в операции Client-2 Request-2, и подготавливает Response-2
                • Цикл событий отправляет Response-2 клиенту-2

                • Проверяет, требует ли Client-n Request-n каких-либо блокирующих операций ввода-вывода или требуется больше времени для сложных вычислительных задач.
                • Поскольку этот запрос представляет собой очень сложное вычисление или задачу блокировки ввода-вывода, четный цикл не обрабатывает этот запрос.
                • Цикл событий выбирает поток T-1 из пула внутренних потоков и назначает этот запрос Client-n Request-n потоку T-1
                • Поток T-1 считывает и обрабатывает Запрос-n, выполняет необходимую блокировку ввода-вывода или вычислительную задачу и, наконец, подготавливает Ответ-n
                • Поток T-1 отправляет этот ответ n в цикл обработки событий
                • Цикл событий, в свою очередь, отправляет этот Response-n клиенту-n

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

                ПРИМЕЧАНИЕ: -

                • Если вы не понимаете, как выполняются эти функции, полагаю, вы не знакомы с функциями Java Script и механизмом обратного вызова.
                • У нас должно быть некоторое представление о функциях Java Script и механизмах обратного вызова. Прежде чем приступить к разработке нашего приложения Node JS, ознакомьтесь с онлайн-руководством.

                Архитектура Node JS — преимущества однопоточного цикла обработки событий

                1. Обрабатывать все больше и больше одновременных клиентских запросов очень просто.
                2. Несмотря на то, что наше приложение Node JS получает все больше и больше одновременных клиентских запросов, нет необходимости создавать все больше и больше потоков из-за цикла событий.
                3. Приложение Node JS использует меньше потоков, поэтому оно может использовать только меньше ресурсов или памяти

                Псевдокод цикла событий

                Поскольку я являюсь 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 T1
                            Else
                                  Process and Prepare response
                  }
            }
}

                Это все, что касается архитектуры Node JS и однопоточного цикла обработки событий Node JS.