So implementieren Sie NodeJS-Multithreading

Node.js ist derzeit eine der beliebtesten Back-End-Programmiersprachen. Die verwendeten ereignisgesteuerten und nicht blockierenden E/A-Funktionen machen es effizienter als andere Sprachen.

Besonders beim Erreichen einer hohen Parallelität kommen die Vorteile der ereignisgesteuerten und nicht blockierenden E/A von Node.js besonders zum Tragen, was eine effizientere Ausführungsmethode für unsere Programme bieten kann.

Aber in einigen Fällen kann der Single-Threaded-Laufmodus tatsächlich zu einem unüberwindbaren Engpass werden, beispielsweise bei der Verarbeitung CPU-intensiver Aufgaben, obwohl Node.js ein asynchrones, nicht blockierendes E/A-Modell zur Lösung von E/A übernommen hat. intensive Probleme und reduzieren die Codekomplexität. Wenn Sie jedoch Multitasking-Bibliotheken wie MPI verwenden, müssen Sie dennoch eine Multithreading-Lösung implementieren. Das Single-Thread-Modell von Node.js unterstützt jedoch kein Multi-Threading, sodass zur Implementierung von Multi-Threading-Lösungen andere Methoden verwendet werden müssen.

In diesem Artikel stellen wir einige Lösungen vor, mit denen sich Multithreading in Node.js implementieren lässt, und unter welchen Umständen sie am effektivsten sind.

1. Untergeordneter Prozess

Das Modul „Untergeordneter Prozess“ in Node.js bietet eine Möglichkeit, untergeordnete Prozesse zu erstellen und Multithreading-Lösungen über untergeordnete Prozesse zu implementieren. Jeder untergeordnete Prozess kann in seinem eigenen Thread ausgeführt werden, wodurch das Problem der Blockierung im Hauptprozess vermieden wird.

Mit dem untergeordneten Prozessmodul können wir einige CPU-intensive Aufgaben im untergeordneten Prozess ausführen und verschiedene Strategien für die Aufgabenzuweisung und Dateninteraktion auswählen. Das Folgende ist ein Beispiel für die Verwendung eines untergeordneten Prozesses zur Implementierung einer Multithread-Addition:

const { fork } = require('child_process');

// 创建子进程
const worker = fork('./worker');

// 向子进程发送数据
worker.send({a: 1, b: 2});

// 接收来自子进程的数据
worker.on('message', result => {
  console.log(result);
})

// 错误处理
worker.on('error', err => {
  console.log(err);
})

In diesem Beispiel verwenden wir zunächst das untergeordnete Prozessmodul, um einen untergeordneten Prozess zu erstellen, und senden dann Daten über worker.send( an den untergeordneten Prozess. ) Methode Der untergeordnete Prozess Nach der Berechnung wird das Ergebnis an den Hauptprozess zurückgegeben und der Rückgabewert wird über die Methode worker.on('message') empfangen. Dies ermöglicht Multithread-Berechnungen.

2. Worker-Threads

Node.js bietet eine weitere Möglichkeit, Multithreading zu implementieren: Worker-Threads, die es uns ermöglichen, einen Sub-Thread unabhängig vom Haupt-Thread zu starten. Dieser Sub-Thread kann einige zeitaufwändige Aufgaben ausführen. Dadurch wird das Problem der Blockierung des Hauptthreads in einem Single-Thread-Modell vermieden.

Im Gegensatz zu untergeordneten Prozessen teilen sich Worker-Threads den Speicher vollständig. Sie können JavaScript-Code in einer unabhängigen Umgebung ausführen, ohne sich Gedanken über die gemeinsame Nutzung von Daten machen zu müssen.

Das Folgende ist ein Beispiel für die Verwendung von Worker-Threads zur Implementierung von Multithread-Additionsoperationen:

const { Worker } = require('worker_threads');

function runService() {
  // 创建 Worker 线程
  const worker = new Worker(`
    const add = (a, b) => a + b;
    const { parentPort } = require('worker_threads');

    // 接收来自主线程的数据
    parentPort.on('message', message => {
      // 子线程执行加法运算
      const result = add(message.a, message.b);

      // 将结果发送给主线程
      parentPort.postMessage(result);
    });
  `);

  return worker;
}

// 启动 Worker 线程
const worker = runService();

// 向 Worker 线程发送数据
worker.postMessage({ a: 1, b: 2 });

// 接收来自 Worker 线程的数据
worker.on('message', result => {
  console.log(result);
});

// 错误处理
worker.on('error', err => {
  console.log(err);
});

Hier verwenden wir Worker-Threads, um eine unabhängige Sub-Thread-Umgebung zu erstellen, in der unsere Berechnungslogik ausgeführt wird. Senden Sie Daten über die Methode worker.postMessage() an den untergeordneten Thread und empfangen Sie die vom untergeordneten Thread zurückgegebenen Berechnungsergebnisse über die Methode worker.on('message'). Auf diese Weise erreichen wir Multithread-Computing.

3. Cluster

Eine weitere Lösung zur Implementierung von Multithreading in Node.js ist die Verwendung des Cluster-Moduls von Node.js. Das Cluster-Modul erreicht einen Lastausgleich durch die Verteilung von Verbindungen auf mehrere Prozesse. Mit anderen Worten: Die Verwendung mehrerer Prozesse kann die Systemleistung bei der Verarbeitung zeitaufwändiger Aufgaben erheblich verbessern.

In einigen Fällen ist das Cluster-Modul möglicherweise besser geeignet als untergeordnete Prozess- und Worker-Threads für die Behandlung von Datenparallelitätsproblemen. Um das Cluster-Modul zu verwenden, müssen Sie die folgenden Schritte ausführen:

const cluster = require('cluster');
const http = require('http');

if (cluster.isMaster) {
  // 获取 CPU 的核心数
  const numCPUs = require('os').cpus().length;

  // fork 子进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  // 处理 worker exit 事件
  cluster.on('exit', (worker, code, signal) => {
    console.info(`Worker ${worker.process.pid} died`);
  });
} else {
  const server = http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`hello world from ${process.pid}`);
  });

  server.listen(8000, () => {
    console.info(`Server running at http://localhost:8000/ in worker process with pid ${process.pid}`);
  });
}

In diesem Beispiel ermitteln wir zunächst, ob es sich um den Hauptprozess handelt. Wenn ja, forken Sie mehrere untergeordnete Prozesse und hören Sie auf die Exit-Ereignisse jedes untergeordneten Prozesses Der Hauptprozess kann benachrichtigt werden, wenn ein Fehler auftritt. Andernfalls wird im untergeordneten Prozess ein HTTP-Dienst erstellt und die PID des aktuellen untergeordneten Prozesses wird durch den in der Listen-Methode übergebenen Parameter angegeben.

Zusammenfassung

Die oben genannten sind die drei Hauptlösungen für die Implementierung von Multithreading in Node.js: Untergeordneter Prozess, Worker-Threads und Cluster. Die ersten beiden eignen sich besser für die Verarbeitung CPU-intensiver Aufgaben, während letztere besser geeignet ist Verarbeitung von Netzwerkverbindungen. Wird bei der Ausführung von Aspektaufgaben und der Implementierung des Lastausgleichs verwendet. Natürlich gibt es auch andere Lösungen, z. B. die Verwendung von Web Workern oder die Verwendung von C++-Bibliotheken auf niedrigerer Ebene zur Implementierung von Multithreading usw.

Bei der Verwendung der oben genannten Lösungen müssen Sie auf einige Details achten, wie z. B. die Richtigkeit der Daten und Probleme mit dem gemeinsam genutzten Speicher usw., aber mithilfe dieser Lösungen können wir auch effiziente und skalierbare Verarbeitungsfunktionen für Node bereitstellen .js-Anwendungen erzielen eine bessere Leistung.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie NodeJS-Multithreading. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!