Ein Artikel über Multi-Processing und Multi-Threading von Nodes

Dieser Artikel wird Ihnen helfen, node.js zu verstehen, Multiprozess und Multithreading in node einzuführen und Multiprozess und Multithread zu vergleichen. Ich hoffe, dass er für alle hilfreich ist!

Multiprozess und Multithreading in node.js

In node.js erfolgt die Ausführung von Javascript-Code Single-Threaded, Node selbst ist jedoch tatsächlich Multi-Threaded.

Knoten selbst ist in drei Schichten unterteilt

Die erste Schicht, Node.js Standardbibliothek, dieser Teil wird von Javascript geschrieben, also der API, die wir während der Verwendung direkt aufrufen können, im Quellcode Sie können es im lib-Verzeichnis sehen.

Die zweite Schicht, Knotenbindungen, ist der Schlüssel zur Kommunikation zwischen Javascript und dem zugrunde liegenden C/C++. Ersteres ruft letzteres über Bindungen auf und tauscht Daten untereinander aus. Es ist die Brücke zwischen der ersten Schicht und die dritte Schicht.

Die dritte Schicht ist der Schlüssel zur Unterstützung des Betriebs von Node.js. Sie wird von C/C++ implementiert und ist ein Teil der zugrunde liegenden Logik, die von Node implementiert wird.

Unter anderem stellt die dritte Schicht von Libuv Node.js plattformübergreifende, Thread-Pools, Ereignispools, asynchrone E/A und andere Funktionen zur Verfügung, was der Schlüssel zur Leistungsfähigkeit von Node.js ist.

Da Libuv einen Ereignisschleifenmechanismus bereitstellt, blockiert JavaScript die E/A-Verarbeitung nicht. Wenn wir Knoten zum Erstellen von Webdiensten verwenden, müssen wir uns daher keine Sorgen über ein übermäßiges E/A-Volumen machen, das dazu führt, dass andere Anforderungen blockiert werden.

Die Ausführung von Nicht-IO-Aufgaben erfolgt jedoch im Hauptthread des Knotens. Es handelt sich um eine Single-Thread-Ausführungsaufgabe, die die Ausführung anderer Codes blockiert .

const Koa = require('koa');
const app = new Koa();

app.use(async (ctx) => {
    const url = ctx.request.url;
    if (url === '/') {
        ctx.body = {name: 'xxx', age: 14}
    }
    if(url==='/compute'){
        let sum=0
        for (let i = 0; i <100000000000 ; i++) {
        sum+=i    
        }
        ctx.body={sum}
    }
})
app.listen(4000, () => {
    console.log(&#39;http://localhost:4000/ start&#39;)
})

Wenn http im obigen Code /compute anfordert, ruft der Knoten die CPU auf, um eine große Anzahl von Berechnungen durchzuführen. Wenn zu diesem Zeitpunkt andere http-Anfragen eingehen, kommt es zu einer Blockierung.

/compute ,node会调用cpu进行大量的计算，这时如果有其他http请求进入，将会发生阻塞。

那么如何解决这个问题呢？

有两种方案，一种是使用children_process或者cluster开启多进程进行计算，一种是使用worker_thread

Wie kann man dieses Problem lösen?

Es gibt zwei Lösungen: Eine besteht darin, children_process oder cluster zu verwenden, um die Multiprozessberechnung zu ermöglichen, die andere darin, worker_thread zu verwenden Aktivieren Sie Multi-Threading-Berechnungen

Multi-Process gegen Multi-thread

compare-Multi-Threading und Multi-Process: multi-thread comparisonBeansprucht weniger Speicher, einfaches Umschalten, hohe CPU-AuslastungErstellen, zerstören, wechseln einfach, schnellKomplexes Codieren und DebuggenThreads atmen und teilen das gleiche Schicksal. Kann nur für die Multi-Core-Verteilung verwendet werdenMultiprozess ist besserVerwenden Sie Multithreading, um das oben genannte Codeberechnungsproblem zu lösen:

//api.js
const Koa = require('koa');
const app = new Koa();

const {Worker} = require('worker_threads')
app.use(async (ctx) => {
    const url = ctx.request.url;
    if (url === '/') {
        ctx.body = {name: 'xxx', age: 14}
    }

    if (url === '/compute') {
        const sum = await new Promise(resolve => {
            const worker = new Worker(__dirname+'/compute.js')
          //接收信息
            worker.on('message', data => {
                resolve(data)
            })
        })
        ctx.body = {sum}

    }
})
app.listen(4000, () => {
    console.log('http://localhost:4000/ start')
})



//computer.js
const {parentPort}=require('worker_threads')
let sum=0
for (let i = 0; i <1000000000 ; i++) {
    sum+=i
}
//发送信息
parentPort.postMessage(sum)

Hier ist das offizielle Dokument, https ://nodejs.org/dist/latest-v16.x/docs/api/worker_threads.htmlVerwendung mehrerer Prozesse zur Lösung des Berechnungsproblems des obigen Codes:

//api.js
const Koa = require('koa');
const app = new Koa();
const {fork} = require('child_process')

app.use(async (ctx) => {
    const url = ctx.request.url;
    if (url === '/') {
        ctx.body = {name: 'xxx', age: 14}
    }

    if (url === '/compute') {
        const sum = await new Promise(resolve => {
          const worker =fork(__dirname+'/compute.js')
            worker.on('message', data => {
                resolve(data)
            })
        })
        ctx.body = {sum}

    }
})
app.listen(4000, () => {
    console.log('http://localhost:4000/ start')
})

//computer.js
let sum=0
for (let i = 0; i <1000000000 ; i++) {
    sum+=i
}
process.send(sum)

		Properties	multi-Process
		Datenaustausch ist komplex und erfordert IPC; Daten werden getrennt und die Synchronisierung ist einfach. Da Prozessdaten gemeinsam genutzt werden, ist der Datenaustausch einfach und die Synchronisierung komplex. Jeder hat seine eigenen Vorzüge CPU und Speicher	belegt viel Speicher, komplexes Umschalten und geringe CPU-Auslastung
Multithreading ist besser		Zerstören, Umschalten	Erstellen, zerstören , komplex wechseln, langsam
Mehr Threads sind besser		Codierung	Einfaches Codieren und bequemes Debuggen
Komplexes Codieren und Debuggen		Zuverlässigkeit	Prozesse laufen unabhängig voneinander ab und beeinflussen sich nicht gegenseitig.
Multiprozess ist besser
	worker_threads

Hier ist das offizielle Dokument,

child_process

https://nodejs.org/dist/latest-v16.x/docs/api/child_process.html

Weitere Node-bezogene Informationen. Weitere Informationen finden Sie unter:

nodejs-Tutorial

!

Das obige ist der detaillierte Inhalt vonEin Artikel über Multi-Processing und Multi-Threading von Nodes. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!