Node.js vs .Net-Leistung

Ich habe viel darüber gelesen, dass Node.js schnell ist und große Mengen an Last aufnehmen kann. Hat jemand reale Beweise dafür im Vergleich zu anderen Frameworks, insbesondere .Net? Die meisten Artikel, die ich gelesen habe, sind anekdotisch oder haben keine Vergleiche mit .Net.

Vielen Dank

Als FAST und Handhabung vieler LOAD sind zwei verschiedene Dinge. Ein Server, der wirklich SCHNELL eine Anfrage pro Sekunde bedient, kann völlig krächzen, wenn Sie ihm 500 Anfragen pro Sekunde senden (unter LOAD ).

Sie müssen auch statische (und zwischengespeicherte) und dynamische Seiten berücksichtigen. Wenn Sie sich Sorgen über statische Seiten machen, wird IIS wahrscheinlich den Knoten schlagen, da IIS das Kernel-Modus-Caching verwendet. Dies bedeutet, dass Anforderungen, die eine statische Seite anfordern, nicht einmal aus dem Kernel herauskommen.

Ich vermute, dass Sie nach einem Vergleich zwischen ASP.NET und Knoten suchen. In diesem Kampf werden Sie, nachdem alles kompiliert / interpretiert wurde, wahrscheinlich ziemlich nahe an der Leistung sein. Vielleicht ist .NET ein bisschen SCHNELLER oder der Knoten etwas SCHNELLER , aber es ist wahrscheinlich nah genug, dass es Ihnen egal ist. Ich würde auf .NET wetten, aber ich weiß es nicht genau.

Der Ort, an dem der Knoten wirklich überzeugend ist, ist für die Behandlung von LOAD . Hier unterscheiden sich die Technologien wirklich. ASP.NET reserviert einen Thread für jede Anforderung aus seinem Thread-Pool. Sobald ASP.NET alle verfügbaren Threads erschöpft hat, werden Anforderungen in die Warteschlange gestellt. Wenn Sie "Hello World" -Apps wie das Beispiel von @shankar bereitstellen, ist dies möglicherweise nicht so wichtig, da die Threads nicht blockiert werden und Sie viele Anfragen vor Ihnen bearbeiten können Fäden ausgehen. Das Problem mit dem ASP.NET-Modell tritt auf, wenn Sie E / A-Anforderungen stellen, die den Thread blockieren (Aufruf einer Datenbank, HTTP-Anforderung an einen Dienst, Lesen einer Datei von der Festplatte). Diese Blockierungsanforderungen bedeuten, dass Ihr wertvoller Thread aus dem Thread-Pool nichts tut. Je mehr Blockierungen Sie haben,BELASTUNG Ihre ASP.NET-App.

Um diese Blockierung zu verhindern, verwenden Sie E / A-Abschlussports, für die kein Thread gehalten werden muss, während Sie auf eine Antwort warten. ASP.NET unterstützt dies, aber leider viele der gängigen Frameworks / Bibliotheken in .NET NICHT. Beispielsweise unterstützt ADO.NET E / A-Abschlussports, Entity Framework verwendet diese jedoch nicht. Sie können also eine ASP.NET-App erstellen, die rein asynchron ist und viel Last verarbeitet. Die meisten Benutzer tun dies jedoch nicht, da dies nicht so einfach ist wie die Erstellung einer synchronen App, und Sie möglicherweise einige Ihrer Lieblingsteile nicht verwenden können des Frameworks (wie linq to entity), wenn Sie dies tun.

Das Problem besteht darin, dass ASP.NET (und das .NET Framework) so erstellt wurden, dass keine Meinung zu asynchronen E / A besteht. .NET ist es egal, ob Sie synchronen oder asynchronen Code schreiben. Daher ist es Sache des Entwicklers, diese Entscheidung zu treffen. Ein Teil davon ist, dass Threading und Programmierung mit asynchronen Operationen als "schwierig" angesehen wurden und .NET alle glücklich machen wollte (Noobs und Experten). Es wurde noch schwieriger, weil .NET 3-4 verschiedene Muster für die asynchrone Ausführung hatte. .NET 4.5 versucht, das .NET-Framework zurückzusetzen und nachzurüsten, um ein Modell für asynchrone E / A zu erhalten. Es kann jedoch eine Weile dauern, bis die Frameworks, die Ihnen wichtig sind, es tatsächlich unterstützen.

Die Designer von Node entschieden sich dagegen, dass ALLE E / A asynchron sein sollten. Aufgrund dieser Entscheidung konnten die Knotenentwickler auch die Entscheidung treffen, dass jede Instanz des Knotens ein einzelner Thread ist, um das Thread-Switching zu minimieren, und dass ein Thread nur Code ausführt, der in die Warteschlange gestellt wurde. Dies kann eine neue Anforderung sein, es kann sich um den Rückruf einer DB-Anforderung handeln, es kann sich um den Rückruf einer von Ihnen gestellten http-Rest-Anforderung handeln. Node versucht, die CPU-Effizienz zu maximieren, indem Thread-Kontextwechsel eliminiert werden. Da Node diese Meinung getroffen hat, dass ALL I / O asynchron ist, bedeutet dies auch, dass alle Frameworks / Add-Ons diese Auswahl unterstützen. Es ist einfacher, Apps zu schreiben, die zu 100% asynchron im Knoten sind (da der Knoten Sie zwingt, asynchrone Apps zu schreiben).

Auch hier habe ich keine harten Zahlen, die ich auf die eine oder andere Weise beweisen könnte, aber ich denke, Node würde den LOAD-Wettbewerb für die typische Web-App gewinnen. Eine hochoptimierte (100% asynchrone) .NET-App bietet der entsprechenden node.js-App möglicherweise einen Run für ihr Geld. Wenn Sie jedoch einen Durchschnitt aller .NET- und aller Node-Apps verwenden, verarbeitet der Knoten im Durchschnitt wahrscheinlich mehr BELASTUNG.

Hoffentlich hilft das.

Ich habe einen rudimentären Leistungstest zwischen NodeJS und IIS durchgeführt. IIS ist ungefähr 2,5-mal schneller als NodeJS, wenn "Hallo Welt!" Code unten.

Meine Hardware: Dell Latitude E6510, Core i5 (Dual Core), 8 GB RAM, Windows 7 Enterprise 64-Bit-Betriebssystem

Knotenserver

runs at http://localhost:9090/
/// <reference path="node-vsdoc.js" />
var http = require("http");
http.createServer(function (request, response) {
response.writeHead(200, { "Content-Type": "text/html" });
response.write("<p>hello, world!</p>");
response.end();
}).listen(9090);

default.htm

hosted by iis at http://localhost/test/
<p>hello, world!</p>

mein eigenes Benchmark-Programm mit Task Parallel Library:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using System.Diagnostics;

namespace HttpBench
{
class Program
{
    private int TotalCount = 100000;
    private int ConcurrentThreads = 1000;
    private int failedCount;
    private int totalBytes;
    private int totalTime;
    private int completedCount;
    private static object lockObj = new object();

    /// <summary>
    /// main entry point
    /// </summary>
    static void Main(string[] args)
    {
        Program p = new Program();
        p.Run(args);
    }

    /// <summary>
    /// actual execution
    /// </summary>
    private void Run(string[] args)
    {
        // check command line
        if (args.Length == 0)
        {
            this.PrintUsage();
            return;
        }
        if (args[0] == "/?" || args[0] == "/h")
        {
            this.PrintUsage();
            return;
        }

        // use parallel library, download data
        ParallelOptions options = new ParallelOptions();
        options.MaxDegreeOfParallelism = this.ConcurrentThreads;
        int start = Environment.TickCount;
        Parallel.For(0, this.TotalCount, options, i =>
            {
                this.DownloadUrl(i, args[0]);
            }
        );
        int end = Environment.TickCount;

        // print results
        this.Print("Total requests sent: {0}", true, this.TotalCount);
        this.Print("Concurrent threads: {0}", true, this.ConcurrentThreads);
        this.Print("Total completed requests: {0}", true, this.completedCount);
        this.Print("Failed requests: {0}", true, this.failedCount);
        this.Print("Sum total of thread times (seconds): {0}", true, this.totalTime / 1000);
        this.Print("Total time taken by this program (seconds): {0}", true, (end - start) / 1000);
        this.Print("Total bytes: {0}", true, this.totalBytes);
    }

    /// <summary>
    /// download data from the given url
    /// </summary>
    private void DownloadUrl(int index, string url)
    {
        using (WebClient client = new WebClient())
        {
            try
            {
                int start = Environment.TickCount;
                byte[] data = client.DownloadData(url);
                int end = Environment.TickCount;
                lock (lockObj)
                {
                    this.totalTime = this.totalTime + (end - start);
                    if (data != null)
                    {
                        this.totalBytes = this.totalBytes + data.Length;
                    }
                }
            }
            catch
            {
                lock (lockObj) { this.failedCount++; }
            }
            lock (lockObj)
            {
                this.completedCount++;
                if (this.completedCount % 10000 == 0)
                {
                    this.Print("Completed {0} requests.", true, this.completedCount);
                }
            }
        }
    }

    /// <summary>
    /// print usage of this program
    /// </summary>
    private void PrintUsage()
    {
        this.Print("usage: httpbench [options] <url>");
    }

    /// <summary>
    /// print exception message to console
    /// </summary>
    private void PrintError(string msg, Exception ex = null, params object[] args)
    {
        StringBuilder sb = new System.Text.StringBuilder();
        sb.Append("Error: ");
        sb.AppendFormat(msg, args);
        if (ex != null)
        {
            sb.Append("Exception: ");
            sb.Append(ex.Message);
        }
        this.Print(sb.ToString());
    }

    /// <summary>
    /// print to console
    /// </summary>
    private void Print(string msg, bool isLine = true, params object[] args)
    {
        if (isLine)
        {
            Console.WriteLine(msg, args);
        }
        else
        {
            Console.Write(msg, args);
        }
    }

}
}

und Ergebnisse:

IIS: httpbench.exe http://localhost/test

Completed 10000 requests.
Completed 20000 requests.
Completed 30000 requests.
Completed 40000 requests.
Completed 50000 requests.
Completed 60000 requests.
Completed 70000 requests.
Completed 80000 requests.
Completed 90000 requests.
Completed 100000 requests.
Total requests sent: 100000
Concurrent threads: 1000
Total completed requests: 100000
Failed requests: 0
Sum total of thread times (seconds): 97
Total time taken by this program (seconds): 16
Total bytes: 2000000

nodejs: httpbench.exe http://localhost:9090/

Completed 10000 requests.
Completed 20000 requests.
Completed 30000 requests.
Completed 40000 requests.
Completed 50000 requests.
Completed 60000 requests.
Completed 70000 requests.
Completed 80000 requests.
Completed 90000 requests.
Completed 100000 requests.
Total requests sent: 100000
Concurrent threads: 1000
Total completed requests: 100000
Failed requests: 0
Sum total of thread times (seconds): 234
Total time taken by this program (seconds): 27
Total bytes: 2000000

Fazit: IIS ist etwa 2,5-mal schneller als NodeJS (unter Windows). Dies ist ein sehr rudimentärer Test und keineswegs schlüssig. Aber ich glaube, das ist ein guter Ausgangspunkt. Nodejs ist auf anderen Webservern und Plattformen wahrscheinlich schneller, aber unter Windows ist IIS der Gewinner. Entwickler, die ihre ASP.NET MVC in NodeJS konvertieren möchten, sollten eine Pause einlegen und zweimal überlegen, bevor sie fortfahren.

Aktualisiert (17.05.2012) Tomcat (unter Windows) scheint IIS zweifellos zu schlagen, etwa dreimal schneller als IIS beim Austeilen von statischem HTML.

Kater

index.html at http://localhost:8080/test/
<p>hello, world!</p>

Tomcat Ergebnisse

httpbench.exe http://localhost:8080/test/
Completed 10000 requests.
Completed 20000 requests.
Completed 30000 requests.
Completed 40000 requests.
Completed 50000 requests.
Completed 60000 requests.
Completed 70000 requests.
Completed 80000 requests.
Completed 90000 requests.
Completed 100000 requests.
Total requests sent: 100000
Concurrent threads: 1000
Total completed requests: 100000
Failed requests: 0
Sum total of thread times (seconds): 31
Total time taken by this program (seconds): 5
Total bytes: 2000000

aktualisierte Schlussfolgerung: Ich habe das Benchmark-Programm mehrmals ausgeführt. Tomcat scheint der schnellste Server zu sein, der STATIC HTML ON WINDOWS verteilt.

Aktualisiert (18.05.2012) Zuvor hatte ich insgesamt 100.000 Anfragen mit 10.000 gleichzeitigen Anfragen. Ich habe es auf 1.000.000 Gesamtanforderungen und 100.000 gleichzeitige Anforderungen erhöht. IIS ist der schreiende Gewinner, wobei Nodejs am schlechtesten abschneidet. Ich habe die folgenden Ergebnisse tabellarisch aufgeführt:

.

NIO-Server (Node.js usw.) sind in der Regel schneller als BIO-Server. (IIS usw.). Um meine Behauptung zu untermauern, ist TechEmpower ein Unternehmen, das sich auf Web-Framework-Benchmarks spezialisiert hat . Sie sind sehr offen und haben eine Standardmethode zum Testen aller Framewrks.

Die Tests der 9. Runde sind derzeit die neuesten (Mai 2014). Es wurden viele IIS-Varianten getestet, aber Aspnet-Stripped scheint die schnellste IIS-Variante zu sein.

Hier sind die Ergebnisse in Antworten pro Sekunde (höher ist besser):

• JSON-Serialisierung
  • nodejs: 228,887
  • aspnet-gestrippt: 105,272
• Einzelabfrage
  • nodejs-mysql: 88,597
  • aspnet-stripped-raw: 47,066
• Mehrere Abfragen
  • nodejs-mysql: 8,878
  • aspnet-stripped-raw: 3,915
• Klartext
  • nodejs: 289,578
  • aspnet-gestrippt: 109,136

In allen Fällen ist Node.js in der Regel 2x + schneller als IIS.

Ich muss Marcus Granstrom zustimmen, dass das Szenario hier sehr wichtig ist.

Um ehrlich zu sein, klingt es so, als würden Sie eine wichtige architektonische Entscheidung treffen. Mein Rat wäre, die Problembereiche zu isolieren und zwischen den Stapeln, die Sie in Betracht ziehen, ein "Backen" durchzuführen.

Am Ende des Tages sind Sie für die Entscheidung verantwortlich und ich glaube nicht, dass die Ausrede "Ein Typ von Stackoverflow hat mir einen Artikel gezeigt, der besagt, dass es in Ordnung wäre" wird es mit Ihrem Chef abschneiden.

Der Hauptunterschied, den ich sehe, ist, dass der Knoten .js eine dynamische Programmiersprache ist (Typprüfung), daher müssen die Typen zur Laufzeit abgeleitet werden. Die stark typisierten Sprachen wie C # .NET haben theoretisch viel mehr Potenzial, um den Kampf gegen Node .js (und PHP usw.) zu gewinnen, insbesondere wenn teure Berechnungen erforderlich sind. Übrigens sollte .NET eine bessere native Interaktion mit C / C ++ haben als der Knoten .js.