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:

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!