Artikel untuk membincangkan tentang pemproses berbilang nod dan berbilang benang

Artikel ini akan memperkenalkan anda kepada node.js, memperkenalkan berbilang proses dan berbilang benang dalam nod, dan membandingkan berbilang proses dan berbilang benang, saya harap ia akan membantu semua orang.

Berbilang proses dan berbilang benang dalam node.js

Dalam node.js, pelaksanaan kod javascript adalah tunggal -Pelaksanaan berulir, tetapi Node itu sendiri sebenarnya berbilang benang.

Nod itu sendiri terbahagi kepada tiga lapisan

Lapisan pertama , Pustaka standard Node .js, bahagian ini ditulis dalam Javascript, iaitu API yang boleh kita panggil terus semasa digunakan, yang boleh dilihat dalam direktori lib dalam kod sumber.

Lapisan kedua , Pengikatan Nod, lapisan ini adalah kunci untuk Javascript untuk berkomunikasi dengan C/C yang mendasari memanggil yang kedua melalui pengikatan dan bertukar-tukar data antara satu sama lain ialah lapisan pertama dan jambatan peringkat Ketiga.

Lapisan ketiga ialah kunci untuk menyokong operasi Node.js Ia dilaksanakan oleh C/C dan merupakan sebahagian daripada logik asas yang dilaksanakan oleh nod.

Antaranya, lapisan ketiga Libuv menyediakan Node.js dengan platform merentas, kumpulan benang, kumpulan acara, I/O tak segerak dan keupayaan lain, yang merupakan kunci untuk menjadikan Node.js begitu berkuasa.

Memandangkan Libuv menyediakan mekanisme gelung peristiwa, JavaScript tidak akan menyekat dalam pemprosesan io Oleh itu, apabila kami menggunakan nod untuk membina perkhidmatan web, kami tidak perlu risau tentang volum io yang berlebihan menyebabkan permintaan lain disekat.

Walau bagaimanapun, pelaksanaan tugasan bukan IO dilaksanakan dalam utas utama nod Ia adalah tugas pelaksanaan satu utas Jika terdapat tugas pengiraan segerak yang memakan masa menyekat pelaksanaan kod lain.

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

Dalam kod di atas, jika permintaan http dibuat /compute, nod akan memanggil CPU untuk melakukan sejumlah besar pengiraan Pada masa ini, jika permintaan http lain masuk , penyekatan akan berlaku.

Jadi bagaimana untuk menyelesaikan masalah ini?

Terdapat dua penyelesaian, satu ialah menggunakan children_process atau cluster untuk membolehkan pengiraan berbilang proses, satu lagi menggunakan worker_thread untuk membolehkan berbilang benang untuk pengiraan

Berbilang proses vs berbilang benang

Bandingkan berbilang benang dan berbilang proses:

属性	多进程	多线程	比较
数据	数据共享复杂，需要用IPC；数据是分开的，同步简单	因为共享进程数据，数据共享简单，同步复杂	各有千秋
CPU、内存	占用内存多，切换复杂，CPU利用率低	占用内存少，切换简单，CPU利用率高	多线程更好
销毁、切换	创建销毁、切换复杂，速度慢	创建销毁、切换简单，速度很快	多线程更好
coding	编码简单、调试方便	编码、调试复杂	编码、调试复杂
可靠性	进程独立运行，不会相互影响	线程同呼吸共命运	多进程更好
分布式	可用于多机多核分布式，易于扩展	只能用于多核分布式	多进程更好

Gunakan berbilang benang untuk menyelesaikan masalah pengiraan kod di atas:

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

Berikut ialah dokumentasi rasmi, worker_threads

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

Gunakan berbilang proses untuk menyelesaikan masalah pengiraan kod di atas:

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

Berikut ialah dokumen rasmi, proses_kanak-kanak

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

Untuk lebih banyak pengetahuan berkaitan nod, sila lawati: tutorial nodejs!

Atas ialah kandungan terperinci Artikel untuk membincangkan tentang pemproses berbilang nod dan berbilang benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!