Beispiele für Methoden zur Verwendung von Multithread-Programmierung in nodejs_node.js

In meinem vorherigen Blog-Beitrag Sagen Sie nicht, dass es unmöglich ist, implementieren Sie Sleep in NodeJS , ich habe Ihnen die Verwendung des NodeJS-Add-Ons vorgestellt. Das heutige Thema ist immer noch Add-on. Erkunden Sie weiterhin die Fähigkeiten von C/C und gleichen Sie die Schwächen von NodeJS aus.

Ich habe die Leistungsprobleme von NodeJS schon oft erwähnt. Was die Sprache selbst betrifft, ist die Leistung von NodeJS zwar nicht so gut wie die der meisten statischen Sprachen, der Unterschied zu anderen dynamischen Sprachen ist jedoch nicht groß . Aber warum sagen wir oft, dass NodeJS nicht für CPU-intensive Szenarien geeignet ist? Denn aufgrund seiner Single-Threaded-Natur kann es die CPU für CPU-intensive Szenarien nicht vollständig ausnutzen. In der Informatik gibt es ein berühmtes Amdahl-Gesetz:

Gehen Sie davon aus, dass die Gesamtarbeitslast W in zwei Teile zerlegt werden kann: Ws, das nur seriell berechnet werden kann, und Wp, das eine parallele Berechnung ermöglicht. Dann kann beim parallelen Rechnen von p CPUs die Leistung durch Beschleunigungszeiten verbessert werden. Das Amdahlsche Gesetz beschreibt, was Parallelität bewirken kann und was nicht. Dies ist eine ideale Situation, die tatsächliche Situation wird viel komplexer sein. Beispielsweise führt die Parallelität wahrscheinlich zu Ressourcenkonflikten, die das Hinzufügen verschiedener Sperren erfordern, wodurch die Parallelität häufig in einem Wartezustand verbleibt und außerdem einen zusätzlichen Zeitaufwand für das Betriebssystem verursacht, um die Thread-Planung zu ändern, was die Ws erhöht. Wenn jedoch Wp in einer Aufgabe viel größer als Ws ist und mehrere CPU-Kerne verfügbar sind, ist die Leistungsverbesserung durch Parallelität beträchtlich.

Okay, zurück zu nodejs. Stellen wir uns ein Berechnungsszenario vor: Berechnen Sie die Anzahl der Primzahlen innerhalb von 4.000.000. Wenn dieses Szenario programmiert wird, werden hauptsächlich Divisionsoperationen verwendet und Operationen wie Speicher und Objekte sind nicht beteiligt. Theoretisch kann dadurch sichergestellt werden, dass NodeJS mit einer relativ hohen Geschwindigkeit ausgeführt wird und nicht zu weit hinter c zurückbleibt, was praktisch ist Vergleich.

Die Methode zum Finden von Primzahlen in JavaScript wurde in diesem Blog bereitgestellt, kopieren Sie sie direkt:

Code kopieren Der Code lautet wie folgt:

Funktion zhishu_js(num) {
If (num == 1) {
         return false;
}
If (num == 2) {
        return true;
}
for (var i = 2; i <= Math.sqrt(num); i ) {
If (num % i == 0) {
              return false;
}
}
Gibt true zurück;
}

Schreiben Sie eine weitere C-Sprachversion:

Code kopieren Der Code lautet wie folgt:

#include

bool zhishu(int num){
If (num == 1) {
         return false;
}
Wenn (num == 2) {
        return true;
}
for (int i = 2; i <= sqrt(num); i ) {
If (num % i == 0) {
              return false;
}
}
Gibt true zurück;
};

In nodejs verwenden wir eine Schleife von 1 bis 4000000, um Primzahlen in der Sprache C abzurufen. Wir richten mehrere Threads ein und definieren die Anzahl als 4000000. Jeder Thread führt Folgendes aus: Wenn die Anzahl größer als 0 ist, wird sie entfernt Der Wert von count, berechnet, ob es sich um eine Primzahl handelt, und dekrementiert count um 1. Nach dieser Idee ist die Javascript-Version einfach zu schreiben:

Code kopieren Der Code lautet wie folgt:

var count = 0;

für (j = 1; j < 4000000; j ) {
If(zhishu(j)){
Zählen ;
}
}

Die Hauptschwierigkeit ist die Multithread-Programmierung in der Sprache C. In den frühen Tagen von C/C wurde die Notwendigkeit paralleler Berechnungen nicht berücksichtigt, sodass die Standardbibliothek keine Multithreading-Unterstützung bot. Verschiedene Betriebssysteme haben normalerweise unterschiedliche Implementierungen. Um dieses Problem zu vermeiden, verwenden wir pthread zur Verarbeitung von Threads.

Laden Sie die neueste Version von pthread herunter. Da ich mit GYP nicht vertraut bin, habe ich lange gebraucht, um die Linkabhängigkeitsbibliothek zu reparieren. Am Ende bestand meine Methode darin, den Quellcode von pthread direkt im Projektverzeichnis abzulegen und pthread.c zum Quellcode hinzuzufügen Liste in binding.gyp, kompilieren Sie pthread einmal beim Kompilieren des Projekts. Die geänderte binding.gyp sieht folgendermaßen aus:

Code kopieren Der Code lautet wie folgt:

{
„Ziele“: [
{
„target_name“: „Hallo“,
„Quellen“: [ „hello.cc“, „pthreads/pthread.c“ ],
„include_dirs“: [
" „pthreads“
],
„Bibliotheken“: [„Ws2_32.lib“]
}
]
}

Natürlich ist meine Methode sehr mühsam. Wenn Sie nur Verweise auf die Bibliothek hinzufügen und Verzeichnisse in pthread einschließen, besteht keine Notwendigkeit, meine Methode zu verwenden.

Dann gehen wir auf alles zum Thema C/C-Multithreading ein und definieren eine Thread-Verarbeitungsfunktion:

Code kopieren Der Code lautet wie folgt:

pthread_mutex_t lock;

void *thread_p(void *null){
int num, x=0;
tun{
          pthread_mutex_lock(&lock);
         num=count--;
         pthread_mutex_unlock(&lock);
If(num>0){
If(zhishu(num))x ;
         }sonst{
             Pause;
}
}while(true);
std::cout<<' '<         null zurückgeben;
}

Zwischen Threads konkurrieren die Zählvariablen miteinander. Wir müssen sicherstellen, dass nur ein Thread die Zählvariable gleichzeitig bedienen kann. Wir fügen eine Mutex-Sperre über pthread_mutex_t lock; hinzu. Wenn pthread_mutex_lock(&lock); ausgeführt wird, prüft der Thread den Sperrstatus. Wenn er gesperrt ist, wird er erneut überprüft. Wenn die Sperre aufgehoben wird, wird er gesperrt und führt den folgenden Code aus. Dementsprechend dient pthread_mutex_unlock(&lock); zum Entsperren des Sperrstatus.

Da der Compiler beim Kompilieren eine Kompilierungsoptimierung durchführt, wird eine Anweisung, wenn sie eindeutig nichts bewirkt und keinen Einfluss auf die Ausführung anderer Anweisungen hat, vom Compiler wegoptimiert. Im obigen Code habe ich den Code zum Zählen der Anzahl der Primzahlen hinzugefügt. Wenn nicht, würde er so aussehen:

Code kopieren Der Code lautet wie folgt:

für (int j = 0; j < 4000000; j ) {
zhishu(j);
}

wird vom Compiler direkt übersprungen und nicht tatsächlich ausgeführt.

Die Schreibmethode zum Hinzufügen von Add-ons wurde eingeführt. Wir erhalten einen Parameter von Javascript, der die Anzahl der Threads angibt, und erstellen dann eine bestimmte Anzahl von Threads in c, um den Primzahlabruf abzuschließen. Vollständiger Code:

Code kopieren Der Code lautet wie folgt:

#include
#include
#include
#include „pthreadspthread.h“
#define MAX_THREAD 100
unter Verwendung des Namespace v8;

int count=4000000;
pthread_t tid[MAX_THREAD];
pthread_mutex_t lock;

void *thread_p(void *null){
    int num, x=0;
    tun{
        pthread_mutex_lock(&lock);
        num=count--;
        pthread_mutex_unlock(&lock);
        if(num>0){
            if(zhishu(num))x ;
        }else{
            Pause;
        }
    }while(true);
    std::cout<<' '<     pthread_exit(NULL);
    return null;
}

NAN_METHOD(Zhishu){
    NanScope();
    pthread_mutex_init(&lock,NULL);
    double arg0=args[0]->NumberValue();
    int c=0;
    for (int j = 0; j < arg0 && j         pthread_create(&tid[j],NULL,thread_p,NULL);
    }
    for (int j = 0; j < arg0 && j         pthread_join(tid[j],NULL);
    }
    NanReturnUndefined();
}

void Init(Handle