Асинхронность Node.js против Java, в чем подвох?

Зато, если какой обработчик пытается сделать блокирующую операцию - виснут все остальные обработчики

делая и пул потоков и работая в асинхронном режиме.

Почему? обработчики = потоки, да? Почему если один поток застрял на тяжелой операции, остальные тоже повисли? С чего бы?

Пользователь. Веб сервера обслуживают запросы от пользователей. При попытке посмотреть, например, эту страницу, ваш браузер отправляет веб-серверу запрос

ничто не мешает на Java/C/C#/Go/Python/даже, при большом желании, на php написать приложение, которое будет обрабатывать пользовательские запросы точно так же

этот поток пошел к базе данных и повис на тяжелом запросе

этот поток должен был закинуть запрос куда-то в очередь

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

listener.BeginAccept( 
                    new AsyncCallback(AcceptCallback),
                    listener );

public static void AcceptCallback(IAsyncResult ar) {
...
Socket handler = listener.EndAccept(ar); //получаем новый сокет, который и есть запрос на соединение
...
handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
            new AsyncCallback(ReadCallback), state); //Говорим ос, что мы готовы принимать байты на сокете, в какой буфер, начиная с 0 байта буфера, размер буфера, колбек для обработки пришедших данных, какой то там объект, чтоб нам было удобнее работать
}

public static void ReadCallback(IAsyncResult ar) {
        StateObject state = (StateObject) ar.AsyncState; //для какого объекта пришли данные
        Socket handler = state.workSocket; //сокет для работы с нашим клиентом
... //всякая важная работа, т.е. логика  для работы с сетью внутри нашего приложения
               handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                new AsyncCallback(ReadCallback), state); // cнова просим ос принять нам данные и оповестить, когда они будут готовы

парсим запрос //тратим, условно, 0.5 мкс
чего-то считаем, что можем посчитать //0.5-1 мкс  (данные для этого у нас есть рядом в памяти)
запрашиваем нужное файло у ос/по сети и ждем ответ//10-500 мкс
компонуем ответ //1-2 мкс
отсылаем ответ клиенту //1-2 мкс

парсим запрос //тратим, условно, 0.1-0.5 мкс
чего-то считаем, что можем посчитать //0.5-1 мкс (данные для этого у нас есть рядом в памяти)
запрашиваем нужное файло у ос/по сети //0.3 мкс, здесь начинается параллелизм
переключаемся на другой запрос из списка обрабатываемых //0.1 мкс
чего то делаем с другим(и) запросом(ами) //10-500 мкс пока не пришла инфа для предыдущего запроса
пришла инфа, переключаемся обратно, получаем инфу //0.1-0.2 мкс потому, что ос уже положила инфу нам в память
компонуем ответ //1-2 мкс
отсылаем ответ клиенту //1-2 мкс

приостановить текущее задание и перейти к другому, пока из очереди не получен ответ. Причем, не только какие-то там абстрактные очереди, даже сама ос может работать асинхронно. Т.е. ос уведомляет нас (вызовом callback), когда в сокет пришел ответ/прочитан файл. Из этого коллбека мы определяем для какого запроса пришли данные и продолжаем выполнять тот запрос.

@RequestMapping
public Future<String> get(@RequestParam String input) {
  CompletableFuture<String> future = new CompletableFuture<>();
  return CompletableFuture.supplyAsync(() -> "in the background");
}

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

Истинно-верный путь на Java не знаю, но с ходу нагуглил это.

public class AsyncRequestProcessor implements Runnable

Вот хорошая статья которая объясняет в чём заключается асинхронность в nodeJS

Event loop регистрирует операцию в пуле потоков с нужным коллбеком.

Ну и на nginx еще можно отдавать статику

SpringBoot может выступать как сервером приложений (монолит)

ну, мы тут стараемся для ТСа, а ему это, судя по вопросу, далеко не разумеющееся =(

@RequestMapping
public Future<String> get(@RequestParam String input) {
  CompletableFuture<String> future = new CompletableFuture<>();
  return CompletableFuture.supplyAsync(() -> "in the background");

@RequestMapping
public Future<String> get(@RequestParam String input) {
  CompletableFuture<String> future = new CompletableFuture<>();
  return CompletableFuture.supplyAsync(() -> "in the background");
}

@RequestMapping
public Future<String> get(@RequestParam String input) {
  CompletableFuture<String> future = new CompletableFuture<>();
  return CompletableFuture.supplyAsync(() -> "in the background");
}

Сначала однопоточный на сокетах

Потом сделать его многопоточным

Потом переписать в асинхронном варианте с java.nio.channels

Потом переписать ещё раз на Netty

Потом вдумчиво изучить Servlet API. Это даст вам базу, чтобы понимать как там все происходит