Wie NodeJS mit intensiven Berechnungen umgeht

Wie gehen NodeJS mit intensiven Berechnungen um?

Nodejs-intensive CPU-Lösung

Lassen Sie uns zunächst über die Vorteile von Nodejs Single Thread sprechen:

Empfohlen: "Javascript Advanced Tutorial 》

Hohe Leistung: Im Vergleich zu PHP vermeidet es den Aufwand für das häufige Erstellen und Wechseln von Threads, führt schneller aus und beansprucht weniger Ressourcen.

Thread-sicher, Sie müssen sich keine Sorgen machen, dass dieselbe Variable von mehreren Threads gelesen und geschrieben wird und das Programm abstürzt.

Single-Threaded asynchron und non-blocking Tatsächlich sind die zugrunde liegenden Nodejs-Zugriffs-E/A Multithreading/nicht-blockierend und asynchron/synchronisierend. Aber das Blockieren ist auf jeden Fall etwas kompliziert. Bitte geben Sie mir ein Beispiel: Ich habe mich für Set A entschieden, und dann hat mir das Personal beim Zubereiten des Essens geholfen Damit das Personal das Essen für mich zubereiten kann, wäre diese Situation so: Wenn das Personal mir beim Zubereiten des Essens hilft, beginnen die Leute hinter mir mit der Bestellung, sodass der Bestellservice in der gesamten Kantine nicht aufhört, weil ich es bin Warten auf Satz A. Diese Situation wird als nicht blockierend bezeichnet. Dieses Beispiel veranschaulicht lediglich die synchrone, aber nicht blockierende Situation. Wenn ich außerdem ein Getränk kaufe, während ich auf das Essen warte, und dann zurückgehe, um das festgelegte Essen zu holen, wenn meine Nummer angerufen wird, wurde mein Getränk bereits gekauft. Auf diese Weise warte ich auf das Essen bedient werden, erledige ich auch die Aufgabe, ein Getränk zu kaufen. Das Anrufen der Nummer entspricht Sobald der Rückruf ausgeführt wird, erfolgt er asynchron und nicht blockierend. Wenn beim Kauf eines Getränks meine Nummer angerufen wurde, damit ich die festgelegte Mahlzeit erhalten kann, ich aber lange auf das Getränk warten muss, kann es sein, dass ich die festgelegte Mahlzeit A erst lange nach der Nummer meiner Mahlzeit erhalte Rufen Sie die Lobby auf, was bedeutet, dass ein einzelner Thread blockiert ist.

Multi-Threading:

Thread ist eine Grundeinheit der CPU-Planung. Eine CPU kann nur eine Thread-Aufgabe ausführen.

Nodejs können auch Multithread-Aufgaben ausführen, z. B. das Referenzieren des TAGG/TAGG2-Moduls, aber sowohl tagg/tagg2 verwenden die pthread-Bibliothek als auch die V8::Isolate-Klasse, um die js-Multithreading-Funktion zu implementieren Gemäß den Regeln können wir in Threads ausgeführte Funktionen nicht die Kern-API von NodeJS wie FS- und Krypto-Module verwenden, daher gibt es immer noch große Einschränkungen.

Mehrere Prozesse:

In Browsern, die HTML5 unterstützen, können wir Webworker verwenden, um einige zeitaufwändige Berechnungen zur Ausführung in den Arbeitsprozess zu werfen, sodass der Hauptprozess nicht blockiert wird und der Benutzer Es wird kein Verzögerungsgefühl geben.

Hier müssen wir das child_process-Modul von nodejs verwenden, das die Fork-Methode bereitstellt, die eine nodejs-Datei starten und sie als Worker-Prozess betrachten kann, an den das Ergebnis gesendet wird Der Hauptprozess wird beendet, und der Worker wird dann automatisch beendet, sodass wir mehrere Prozesse verwenden können, um das Problem der Blockierung des Hauptthreads zu lösen.

var express = require('express');
var fork = require('child_process').fork;
var app = express();
app.get('/', function(req, res){
  var worker = fork('./work.js') //创建一个工作进程
  worker.on('message', function(m) {//接收工作进程计算结果
          if('object' === typeof m && m.type === 'fibo'){
                   worker.kill();//发送杀死进程的信号
                   res.send(m.result.toString());//将结果返回客户端
          }
  });
  worker.send({type:'fibo',num:~~req.query.n || 1});
  //发送给工作进程计算fibo的数量
});
app.listen(7878);

Wir lauschen Port 7878 über Express. Für jede Benutzeranforderung forken wir einen untergeordneten Prozess, übergeben den Parameter n an den untergeordneten Prozess, indem wir die Methode worker.send aufrufen und gleichzeitig abhören Das Nachrichtenereignis der vom untergeordneten Prozess gesendeten Nachricht antwortet dem Client mit dem Ergebnis.

Das Folgende ist der Inhalt der gespaltenen Datei work.js:

var fibo = function fibo (n) {//定义算法
   return n > 1 ? fibo(n - 1) + fibo(n - 2) : 1;
}
process.on('message', function(m) {
//接收主进程发送过来的消息
          if(typeof m === 'object' && m.type === 'fibo'){
                  var num = fibo(~~m.num);
                  //计算jibo
                  process.send({type: 'fibo',result:num})
                  //计算完毕返回结果       
          }
});
process.on('SIGHUP', function() {
        process.exit();//收到kill信息，进程退出
});

Wir definieren zuerst die Funktion fibo, um das Fibonacci-Array zu berechnen, und hören dann die vom Hauptthread gesendeten Nachrichten ab. Die Berechnung ist abgeschlossen. Senden Sie dann das Ergebnis an den Hauptthread. Gleichzeitig lauscht es auch auf das SIGHUP-Ereignis des Prozesses. Wenn dieses Ereignis ausgelöst wird, wird der Prozess beendet.

Eine Sache, die wir hier beachten müssen, ist, dass die Kill-Methode des Hauptthreads nicht tatsächlich zum Beenden des untergeordneten Prozesses führt, sondern das SIGHUP-Ereignis des untergeordneten Prozesses auslöst. Der eigentliche Ausgang hängt immer noch vom Prozess ab. Ausfahrt().

Zusammenfassung:

Die Verwendung der Fork-Methode des child_process-Moduls kann es uns tatsächlich ermöglichen, das Blockierungsproblem von Single-Threaded-CPU-intensiven Aufgaben zu lösen, aber gleichzeitig ist dies unmöglich Verwenden Sie Node.js ohne das Tagg-Paket. Einschränkungen der Kern-API.

Asynchrones Node.js mit einem Thread bedeutet nicht, dass es nicht blockiert, wenn zu viele Aufgaben im Hauptthread ausgeführt werden, was dazu führen kann, dass der Hauptthread hängen bleibt und die Leistung des gesamten Programms beeinträchtigt wird Seien Sie bei der Bearbeitung einer großen Anzahl von Aufgaben sehr vorsichtig, z. B. Schleifen, String-Splicing und Gleitkommaoperationen. Es ist sinnvoll, verschiedene Technologien zu verwenden, um Aufgaben Sub-Threads oder Sub-Prozessen zuzuordnen, die ausgeführt werden sollen Node.js Hauptthread geöffnet.

Die Verwendung von Threads/Prozessen ist nicht ohne Overhead. Wenn Sie die Anzahl der Erstellung und Zerstörung von Threads/Prozessen so weit wie möglich reduzieren, können Sie die Gesamtleistung und Fehlerwahrscheinlichkeit unseres Systems verbessern.

Das obige ist der detaillierte Inhalt vonWie NodeJS mit intensiven Berechnungen umgeht. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!