Saya melakukan tes stres cepat pada dua (agak) halo proyek dunia yang ditulis node.js dan asp.net-core. Keduanya berjalan dalam mode produksi dan tanpa logger yang menyertainya. Hasilnya mencengangkan! Inti ASP.NET mengungguli aplikasi node.js bahkan setelah melakukan beberapa pekerjaan tambahan sedangkan aplikasi node.js hanya menampilkan tampilan.

Aplikasi 1: http://localhost:3000/nodejs node.js

Menggunakan : node.js, mesin rendering ekspres dan vash.

Kode di titik akhir ini adalah

router.get('/', function(req, res, next) {
  var vm = {
    title: 'Express',
    time: new Date()
  }
  res.render('index', vm);
});

Seperti yang Anda lihat, itu tidak melakukan apa-apa selain mengirim tanggal saat ini melalui timevariabel ke tampilan.

Aplikasi 2: http://localhost:5000/aspnet-core asp.net core

Menggunakan : ASP.NET Core, penargetan templat defaultdnxcore50

Namun aplikasi ini melakukan sesuatu selain dari hanya merender halaman dengan tanggal di atasnya. Ini menghasilkan 5 paragraf dari berbagai teks acak. Ini secara teoritis harus membuat ini sedikit lebih berat daripada aplikasi nodejs.

Berikut adalah metode tindakan yang merender halaman ini

[ResponseCache(Location = ResponseCacheLocation.None, NoStore = true)]
[Route("aspnet-core")]
public IActionResult Index()
{
    var sb = new StringBuilder(1024);
    GenerateParagraphs(5, sb);

    ViewData["Message"] = sb.ToString();
    return View();
}

Hasil tes stres

Hasil stress test Node.js App

Pembaruan: Mengikuti saran dari Gorgi Kosev

Menggunakan npm install -g recluster-cli && NODE_ENV=production recluster-cli app.js 8

Hasil tes stres ASP.NET Core App

Tidak bisa mempercayai mataku! Tidak mungkin benar bahwa dalam tes dasar ini inti asp.net jauh lebih cepat daripada nodejs. Tentunya ini bukan satu-satunya metrik yang digunakan untuk mengukur kinerja antara dua teknologi web ini, tetapi saya bertanya-tanya apa yang saya lakukan salah di sisi node.js? .

Menjadi pengembang asp.net profesional dan ingin mengadaptasi node.js dalam proyek-proyek pribadi, ini agak membuat saya kecewa - karena saya sedikit paranoid tentang kinerja. Saya pikir node.js lebih cepat dari inti asp.net (secara umum - seperti yang terlihat di berbagai tolok ukur lainnya) Saya hanya ingin membuktikannya kepada diri saya sendiri (untuk mendorong diri saya dalam mengadaptasi node.js).

Harap balas komentar jika Anda ingin saya memasukkan lebih banyak cuplikan kode.

Pembaruan: Distribusi waktu aplikasi .NET Core

Respons server

HTTP/1.1 200 OK
Cache-Control: no-store,no-cache
Date: Fri, 12 May 2017 07:46:56 GMT
Pragma: no-cache
Transfer-Encoding: chunked
Content-Type: text/html; charset=utf-8
Server: Kestrel

Seperti yang telah disinggung oleh banyak orang lain, perbandingan itu tidak memiliki konteks.
Pada saat dirilis, pendekatan async dari node.js adalah revolusioner. Sejak itu bahasa lain dan kerangka kerja web telah mengadopsi pendekatan yang mereka ambil arus utama.

Untuk memahami apa perbedaannya, Anda perlu mensimulasikan permintaan pemblokiran yang mewakili beberapa beban kerja IO, seperti permintaan basis data. Di sistem utas per permintaan, ini akan menghabiskan threadpool dan permintaan baru akan dimasukkan ke antrian menunggu utas tersedia.
Dengan kerangka kerja non-blocking-io ini tidak terjadi.

Pertimbangkan server node.js ini yang menunggu 1 detik sebelum merespons

const server = http.createServer((req, res) => {
  setTimeout(() => {
    res.statusCode = 200;
    res.end();
  }, 1000);
});

Sekarang mari kita lemparkan 100 konkurensi konkuren untuk 10s. Jadi kami berharap sekitar 1000 permintaan selesai.

$ wrk -t100 -c100 -d10s http://localhost:8000
Running 10s test @ http://localhost:8000
  100 threads and 100 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     1.01s    10.14ms   1.16s    99.57%
    Req/Sec     0.13      0.34     1.00     86.77%
  922 requests in 10.09s, 89.14KB read
Requests/sec:     91.34
Transfer/sec:      8.83KB

Seperti yang dapat Anda lihat, kami tiba di stadion baseball dengan 922 selesai.

Sekarang perhatikan kode asp.net berikut, ditulis seolah-olah async / menunggu belum didukung, oleh karena itu dating kembali ke era peluncuran node.js.

app.Run((context) =>
{
    Thread.Sleep(1000);
    context.Response.StatusCode = 200;
    return Task.CompletedTask;
});

$ wrk -t100 -c100 -d10s http://localhost:5000
Running 10s test @ http://localhost:5000
  100 threads and 100 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     1.08s    74.62ms   1.15s   100.00%
    Req/Sec     0.00      0.00     0.00    100.00%
  62 requests in 10.07s, 5.57KB read
  Socket errors: connect 0, read 0, write 0, timeout 54
Requests/sec:      6.16
Transfer/sec:     566.51B

62! Di sini kita melihat batas threadpool. Dengan menyetelnya, kita bisa mendapatkan lebih banyak permintaan bersamaan, tetapi dengan biaya lebih banyak sumber daya server.

Untuk beban kerja yang terikat IO ini, langkah untuk menghindari pemblokiran thread pemrosesan sangat dramatis.

Sekarang mari kita bawa ke hari ini, di mana pengaruh itu telah beriak melalui industri dan memungkinkan dotnet untuk mengambil keuntungan dari peningkatannya.

app.Run(async (context) =>
{
    await Task.Delay(1000);
    context.Response.StatusCode = 200;
});

$ wrk -t100 -c100 -d10s http://localhost:5000
Running 10s test @ http://localhost:5000
  100 threads and 100 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     1.01s    19.84ms   1.16s    98.26%
    Req/Sec     0.12      0.32     1.00     88.06%
  921 requests in 10.09s, 82.75KB read
Requests/sec:     91.28
Transfer/sec:      8.20KB

Tidak ada kejutan di sini, kami sekarang mencocokkan node.js.

Jadi apa artinya semua ini?

Kesan Anda bahwa node.js adalah "tercepat" berasal dari era kita tidak lagi hidup. Tambahkan ke bahwa itu tidak pernah node / js / v8 yang "cepat", itu adalah bahwa mereka melanggar thread-per-permintaan model. Semua orang sudah menyusul.

Jika tujuan Anda adalah pemrosesan permintaan tunggal yang paling cepat, maka lihatlah tolok ukur yang serius daripada menggulirkan permintaan Anda sendiri. Tetapi jika sebaliknya yang Anda inginkan hanyalah sesuatu yang memenuhi standar modern, maka pilih bahasa apa pun yang Anda suka dan pastikan Anda tidak memblokir utas tersebut.

Penafian: Semua kode ditulis, dan tes dijalankan, pada MacBook Air yang menua selama Minggu pagi yang mengantuk. Jangan ragu untuk mengambil kode dan mencobanya di Windows atau sesuaikan dengan kebutuhan Anda - https://github.com/csainty/nodejs-vs-aspnetcore

Kerangka Node seperti Express dan Koa memiliki overhead yang buruk. "Raw" Node secara signifikan lebih cepat.

Saya belum mencobanya, tetapi ada kerangka kerja yang lebih baru yang mendekati kinerja "Raw" Node: https://github.com/aerojs/aero

(lihat patokan di halaman itu)

pembaruan: Berikut adalah beberapa angka: https://github.com/blitzprog/webserver-benchmarks

Node:
    31336.78
    31940.29
Aero:
    29922.20
    27738.14
Restify:
    19403.99
    19744.61
Express:
    19020.79
    18937.67
Koa:
    16182.02
    16631.97
Koala:
    5806.04
    6111.47
Hapi:
    497.56
    500.00

Seperti yang Anda lihat, overhead dalam kerangka node.js paling populer SANGAT signifikan!