Un article pour parler du multi-traitement et du multi-threading des nœuds

Cet article vous amènera à comprendre node.js, à présenter le multi-processus et le multi-threading dans node et à comparer le multi-processus et le multi-thread. J'espère que cela sera utile à tout le monde !

Multi-processus et multi-threading dans node.js

Dans node.js, l'exécution du code javascript est monothread, mais Node lui-même est en fait multi-thread.

le nœud lui-même est divisé en trois couches

La première couche, la bibliothèque standard Node.js, cette partie est écrite en Javascript, c'est-à-dire l'API que nous pouvons appeler directement pendant l'utilisation, dans le code source Vous pouvez le voir dans le répertoire lib.

La deuxième couche, Liaisons de nœuds, cette couche est la clé de la communication entre Javascript et le C/C++ sous-jacent. La première appelle le second via des liaisons et échange des données entre elles. la troisième couche.

La troisième couche est la clé pour prendre en charge le fonctionnement de Node.js. Elle est implémentée par C/C++ et fait partie de la logique sous-jacente implémentée par node.

Parmi eux, la troisième couche de Libuv fournit à Node.js des fonctionnalités multiplateformes, un pool de threads, un pool d'événements, des E/S asynchrones et d'autres fonctionnalités, ce qui est la clé pour rendre Node.js si puissant.

Étant donné que Libuv fournit un mécanisme de boucle d'événements, JavaScript ne bloquera pas en termes de traitement des E/S. Par conséquent, lorsque nous utilisons un nœud pour créer des services Web, nous n'avons pas à nous soucier d'un volume d'E/S excessif provoquant le blocage d'autres requêtes.

Cependant, l'exécution des tâches non-IO est exécutée dans le thread principal du nœud. Il s'agit d'une tâche d'exécution monothread. S'il y a des tâches de calcul synchrones très chronophages, cela bloquera l'exécution d'autres codes. .

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;)
})

Dans le code ci-dessus, si http demande /compute, le nœud appellera le processeur pour effectuer un grand nombre de calculs. À ce moment, si d'autres requêtes http arrivent, un blocage se produira. /compute ,node会调用cpu进行大量的计算，这时如果有其他http请求进入，将会发生阻塞。

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

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

Alors comment résoudre ce problème ? Il existe deux solutions, l'une consiste à utiliser children_process ou cluster pour activer le calcul multi-processus, l'autre consiste à utiliser worker_thread pour activer le multi-threading Effectuer des calculs

Multi-processus vs multi-threadPropriétésMulti-processusMulti-threadComparaison DonnéesLe partage de données est complexe et nécessite un IPC ; les données sont séparées et la synchronisation est simpleParce que les données de processus sont partagées, le partage de données est simple et la synchronisation est complexechacun a ses propres mérites CPU et mémoireoccupent beaucoup de mémoire, une commutation complexe et une faible utilisation du CPU Occupent moins de mémoire, commutation simple, utilisation élevée du CPULe multithreading est meilleurDestruction, commutationCréer, détruire , Switch Complex, Slow Create, Destring, Switch Simple, Fastm.More Threads est meilleur codage codage simple et débogage pratique du codage et de débogage Les processus s'exécutent indépendamment et ne s'affecteront pas les uns les autresLes threads respirent et partagent le même sort Le multi-processus est meilleurDistribuéPeut être utilisé pour une distribution multi-machines multi-cœurs, facile à étendreNe peut être utilisé que pour la distribution multicœurLe multi-processus est préférable

//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)

Voici le document officiel, worker_threads

Comparer multi-threading et multi-processus :
		Utilisez le multi-threading pour résoudre le problème de calcul de code ci-dessus :

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

Utiliser le multi-processus pour résoudre le problème Le problème de calcul du code ci-dessus :

//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)

Voici le document officiel ,

child_process

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

Plus de détails sur les nœuds Pour plus de connaissances, veuillez visiter : tutoriel Nodejs !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!