Les articles récents sur la série de comparaisons de performances sont devenus très populaires dans la communauté des médias. Au départ, j'ai fait une comparaison du serveur natif de Node/Deno/Bun avec SpringBoot. J'ai reçu des commentaires selon lesquels il s'agissait d'une comparaison injuste. SpringBoot est un framework et doit être comparé à un framework de l'autre côté. Respectant les commentaires, j'ai fait une comparaison de suivi de SpringBoot avec Node/Deno/Bun fonctionnant sur express/fastify. J'ai encore des commentaires selon lesquels une comparaison des serveurs HTTP natifs des deux côtés serait très utile.

Dans cet article et dans quelques articles de suivi, je vais comparer les serveurs natifs fournis par Node.js, Deno, Bun et Go avec le serveur natif de Java. Cet article compare le serveur natif de Node avec le serveur natif de Java.

Tous les articles récents sont visibles sur ma page auteur .

La mise en place

Les tests sont exécutés sur MacBook Pro M1 avec 16G de RAM.

Les versions logicielles sont :

• Node.js v19.8.1
• Java 20

Node.js

import http from "node:http";

http.createServer((req, resp) => {
  try {
    if (req.method !== "GET") {
      return resp.writeHead(405).end();
    }
    if (req.url !== "/") {
      return resp.writeHead(404).end();
    }
    resp.writeHead(200, {
      "content-type": "text/plain",
    });
    resp.end("Hello world");
  } catch (e) {
    resp.writeHead(500).end();
  }
}).listen(3000);

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

public class NativeHelloWorldServer {

    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(3000), 0);
        server.createContext("/", new MyHandler());
        server.setExecutor(Executors.newCachedThreadPool());
        server.start();
    }

    static class MyHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange t) throws IOException {
            String response = "Hello world!";
            t.sendResponseHeaders(200, response.length());
            OutputStream os = t.getResponseBody();
            os.write(response.getBytes());
            os.close();
        }
    }
}

Chaque test est exécuté pour 5 millions (5 millions) de requêtes.

Les tests sont exécutés pour 25, 100 et 300 connexions simultanées.

Le test de charge est effectué à l'aide de l'outil de test HTTP de Bombardier.

Voici les tableaux montrant les résultats pour chaque niveau de simultanéité :

Le serveur HTTP natif de Node s'avère être plus rapide que le serveur natif de Java. La différence n'est pas trop grande, qu'il s'agisse de RPS ou de nombres de latence, mais il y a une différence. De plus, Node utilise très peu de ressources système comme le processeur et la mémoire.

GAGNANT : Node.js

Il pourrait y avoir un argument sur l'utilisation du pool de threads mis en cache en Java. L'autre option consiste à allouer un pool de threads de taille fixe au début. Voici un test rapide utilisant 100 connexions simultanées avec un pool de threads de taille fixe de 125 threads. Le seul changement de ligne dans le code Java est :

//server.setExecutor(Executors.newCachedThreadPool());
server.setExecutor(Executors.newFixedThreadPool(125));

Je ne vois aucune amélioration des performances avec un pool de threads de taille fixe.

Dans les articles suivants, la comparaison avec Java sera présentée pour Deno, Bun et Go.

MISE À JOUR:

• La comparaison de Java avec Deno est maintenant disponible ici
• La comparaison de Java avec Bun est maintenant disponible ici
• Le comparatif de Java avec Go est maintenant disponible ici