mata teras
Kluster adalah kumpulan proses pekerja yang serupa yang berjalan di bawah proses nod induk. Proses pekerja dijana menggunakan kaedah Fork () modul Child_processes. Ini bermakna proses pekerja boleh berkongsi pemegang pelayan dan berkomunikasi dengan proses nod induk menggunakan IPC (komunikasi interprocess). Proses utama bertanggungjawab untuk memulakan dan mengawal proses kerja. Anda boleh membuat banyak proses pekerja yang anda suka dalam proses utama. Juga, ingat bahawa secara lalai, sambungan masuk diperuntukkan pengundian antara proses pekerja (kecuali Windows). Sebenarnya, terdapat satu lagi cara untuk memperuntukkan sambungan masuk, yang saya tidak akan membincangkan di sini, menyerahkan tugasan kepada sistem operasi (tetapan lalai di Windows). Dokumentasi Node.js mengesyorkan menggunakan gaya pengundian lalai sebagai dasar penjadualan. Walaupun menggunakan modul kluster terdengar rumit dalam teori, pelaksanaannya sangat mudah. Untuk memulakan menggunakannya, anda perlu memasukkannya ke dalam aplikasi Node.js anda:
var cluster = require('cluster');Modul kluster melaksanakan proses node.js yang sama beberapa kali. Oleh itu, perkara pertama yang perlu anda lakukan ialah menentukan bahagian kod yang digunakan untuk proses utama dan bahagian kod yang digunakan untuk proses pekerja. Modul kluster membolehkan anda mengenal pasti proses utama seperti berikut:
if(cluster.isMaster) { ... }Proses utama adalah proses yang anda mulakan, yang seterusnya memulakan proses pekerja. Untuk memulakan proses pekerja dalam proses utama, kami akan menggunakan kaedah garpu ():
cluster.fork();
Kaedah ini mengembalikan objek pekerja yang mengandungi beberapa kaedah dan sifat mengenai pekerja yang diperolehi. Kami akan melihat beberapa contoh di bahagian seterusnya. Modul kluster mengandungi pelbagai peristiwa. Dua peristiwa biasa yang berkaitan dengan permulaan proses pekerja dan momen penamatan adalah acara dalam talian dan keluar. Apabila proses pekerja memperoleh dan menghantar mesej dalam talian, acara dalam talian dipancarkan. Apabila proses pekerja mati, acara keluar dipancarkan. Kemudian, kita akan belajar bagaimana menggunakan kedua -dua peristiwa ini untuk mengawal kitaran hayat proses pekerja. Sekarang, mari kita buat semua yang telah kita lihat setakat ini dan tunjukkan contoh yang lengkap.
Contoh
Bahagian ini mengandungi dua contoh. Contoh pertama adalah aplikasi mudah yang menunjukkan cara menggunakan modul kluster dalam aplikasi Node.js. Contoh kedua adalah pelayan ekspres yang mengambil kesempatan daripada modul kluster Node.js, yang merupakan sebahagian daripada kod pengeluaran yang biasanya saya gunakan dalam projek berskala besar. Kedua -dua contoh boleh didapati untuk dimuat turun dari GitHub.
Dalam contoh pertama ini, kami menyediakan pelayan mudah yang memberi respons kepada semua permintaan masuk menggunakan mesej yang mengandungi ID Proses Pekerja yang mengendalikan permintaan. Proses utama memperoleh empat proses pekerja. Dalam setiap proses pekerja, kami mula mendengar port 8000 untuk menerima permintaan masuk. Kod yang melaksanakan apa yang saya nyatakan adalah seperti berikut:
var cluster = require('cluster');
var http = require('http');
var numCPUs = 4;
if (cluster.isMaster) {
for (var i = 0; i < numCPUs; i++) {
cluster.fork();
}
} else {
http.createServer(function(req, res) {
res.writeHead(200);
res.end('process ' + process.pid + ' says hello!');
}).listen(8000);
}Anda boleh mengakses URL dengan memulakan pelayan (menjalankan nod perintah simps.js) dan mengakses url https://www.php.cn/link/7D2D180C45C41870F36E747816456190 .
Express adalah salah satu kerangka aplikasi web yang paling popular untuk Node.js (jika bukan yang paling popular). Kami telah menutupnya beberapa kali di laman web ini. Jika anda berminat untuk mempelajari lebih lanjut, saya cadangkan anda membaca artikel "Membuat API RESTful dengan Express 4" dan "Membina Node.js-Driven Chat Room Web Aplikasi: Express and Azure". Contoh kedua menunjukkan bagaimana untuk membangunkan pelayan ekspres yang sangat berskala. Ia juga menunjukkan bagaimana untuk memindahkan pelayan proses tunggal untuk memanfaatkan modul kluster dengan sedikit kod.
var cluster = require('cluster');Tambahan pertama untuk contoh ini adalah menggunakan modul OS Node.js untuk mendapatkan bilangan teras CPU. Modul OS mengandungi fungsi CPU () yang mengembalikan pelbagai teras CPU. Dengan menggunakan pendekatan ini, kita boleh menentukan secara dinamik bilangan proses pekerja untuk mendapatkan berdasarkan spesifikasi pelayan untuk memaksimumkan penggunaan sumber. Penambahan kedua dan lebih penting adalah untuk menangani kematian proses kerja. Apabila proses pekerja mati, modul kluster akan mengeluarkan acara keluar. Ia boleh diproses dengan mendengar acara itu dan melaksanakan fungsi panggil balik apabila ia dipancarkan. Anda boleh melakukan ini dengan menulis kenyataan seperti cluster.on ('keluar', panggilan balik); Dalam fungsi panggil balik, kami memperoleh proses pekerja baru untuk mengekalkan bilangan proses pekerja yang dijangkakan. Ini membolehkan kami memastikan aplikasi berjalan walaupun dengan beberapa pengecualian yang tidak diawali. Dalam contoh ini, saya juga menyediakan pendengar untuk acara dalam talian, yang dipancarkan apabila proses pekerja diperoleh dan bersedia untuk menerima permintaan masuk. Ini boleh digunakan untuk pembalakan atau operasi lain.
Terdapat beberapa alat untuk menanda aras API, tetapi di sini saya menggunakan alat penanda aras Apache untuk menganalisis bagaimana menggunakan modul kluster mempengaruhi prestasi aplikasi. Untuk menubuhkan ujian, saya membangunkan pelayan Express yang mempunyai laluan dan fungsi panggil balik untuk laluan itu. Dalam fungsi panggil balik, lakukan operasi maya dan kembalikan mesej ringkas. Terdapat dua versi pelayan: seseorang tidak mempunyai proses pekerja, di mana semua operasi berlaku dalam proses utama, dan yang lain mempunyai 8 proses pekerja (kerana mesin saya mempunyai 8 teras). Jadual berikut menunjukkan bagaimana modul gabungan gabungan meningkatkan bilangan permintaan yang diproses sesaat.
| 并发连接 | 1 | 2 | 4 | 8 | 16 |
|---|---|---|---|---|---|
| 单进程 | 654 | 711 | 783 | 776 | 754 |
| 8个工作进程 | 594 | 1198 | 2110 | 3010 | 3024 |
(bilangan permintaan diproses sesaat)
Operasi lanjutan
Semasa menggunakan modul kluster agak mudah, anda boleh menggunakan proses pekerja untuk melaksanakan operasi lain. Sebagai contoh, anda boleh menggunakan modul kluster untuk mencapai (hampir!) Sifar downtime untuk aplikasi anda. Kami akan belajar bagaimana melakukan beberapa operasi ini dalam beberapa ketika.
Kadang -kadang, anda mungkin perlu menghantar mesej dari proses utama ke proses pekerja untuk menetapkan tugas atau melakukan tindakan lain. Sebagai balasan, proses pekerja mungkin perlu memaklumkan proses utama yang telah selesai. Untuk mendengar mesej, anda harus menetapkan pendengar acara untuk acara mesej dalam proses utama dan proses pekerja:
var cluster = require('cluster');Objek pekerja adalah rujukan yang dikembalikan oleh kaedah garpu (). Untuk mendengar mesej dari proses utama dalam proses kerja:
if(cluster.isMaster) { ... }boleh menjadi rentetan atau objek JSON. Untuk menghantar mesej ke proses pekerja tertentu, anda boleh menulis kod seperti ini:
cluster.fork();
Begitu juga, untuk menghantar mesej ke proses utama, anda boleh menulis:
var cluster = require('cluster');
var http = require('http');
var numCPUs = 4;
if (cluster.isMaster) {
for (var i = 0; i < numCPUs; i++) {
cluster.fork();
}
} else {
http.createServer(function(req, res) {
res.writeHead(200);
res.end('process ' + process.pid + ' says hello!');
}).listen(8000);
} Dalam node.js, mesej adalah generik dan tidak mempunyai jenis tertentu. Oleh itu, adalah lebih baik untuk menghantar mesej sebagai objek JSON yang mengandungi beberapa maklumat mengenai jenis mesej, pengirim, dan kandungan itu sendiri. Contohnya:
var cluster = require('cluster');
if(cluster.isMaster) {
var numWorkers = require('os').cpus().length;
console.log('Master cluster setting up ' + numWorkers + ' workers...');
for(var i = 0; i < numWorkers; i++) {
cluster.fork();
}
cluster.on('online', function(worker) {
console.log('Worker ' + worker.process.pid + ' is online');
});
cluster.on('exit', function(worker, code, signal) {
console.log('Worker ' + worker.process.pid + ' died with code: ' + code + ', and signal: ' + signal);
console.log('Starting a new worker');
cluster.fork();
});
} else {
var app = require('express')();
app.all('/*', function(req, res) {res.send('process ' + process.pid + ' says hello!').end();})
var server = app.listen(8000, function() {
console.log('Process ' + process.pid + ' is listening to all incoming requests');
});
}sifar downtime
worker.on('message', function(message) {
console.log(message);
});
process.on('message', function(message) {
console.log(message);
});var cluster = require('cluster');kita boleh mendapatkan ID semua proses pekerja yang sedang berjalan dari objek pekerja dalam modul kluster. Objek ini memegang rujukan kepada semua proses pekerja yang sedang berjalan dan kemas kini secara dinamik apabila proses pekerja ditamatkan dan dimulakan semula. Pertama, kami menyimpan ID semua proses pekerja yang sedang berjalan di array pekerja. Dengan cara ini, kami mengelakkan memulakan semula proses pekerja yang baru diperolehi. Kami kemudian meminta agar setiap proses pekerja ditutup dengan selamat. Sekiranya proses pekerja masih berjalan selepas 5 saat dan masih wujud dalam objek pekerja, maka kami memanggil fungsi membunuh pada proses pekerja untuk memaksanya untuk ditutup. Anda boleh mencari contoh praktikal di GitHub.
Kesimpulan
Aplikasi Node.js boleh dipasangkan menggunakan modul kluster untuk membolehkan penggunaan sistem yang lebih cekap. Proses berganda boleh dijalankan serentak dengan beberapa baris kod, yang menjadikan penghijrahan agak mudah kerana node.js mengendalikan bahagian yang sukar. Seperti yang saya tunjukkan dalam perbandingan prestasi, adalah mungkin untuk mencapai peningkatan yang signifikan dalam prestasi aplikasi dengan memanfaatkan sumber sistem dengan lebih cekap. Sebagai tambahan kepada prestasi, anda boleh meningkatkan kebolehpercayaan aplikasi dan uptime dengan memulakan semula proses pekerja semasa aplikasi sedang berjalan. Iaitu, anda perlu berhati -hati apabila mempertimbangkan menggunakan modul kluster dalam permohonan anda. Penggunaan utama modul kluster yang disyorkan adalah untuk pelayan web. Dalam kes lain, anda perlu melihat dengan lebih dekat bagaimana untuk memperuntukkan tugas antara proses pekerja dan bagaimana untuk menyampaikan kemajuan dengan berkesan antara proses pekerja dan proses utama. Malah untuk pelayan web, pastikan proses node.js tunggal adalah hambatan (memori atau CPU) sebelum membuat sebarang perubahan pada aplikasi anda, kerana perubahan anda mungkin memperkenalkan kesilapan. Akhir sekali, laman web Node.js menyediakan dokumentasi yang baik untuk modul kluster. Oleh itu, pastikan anda menyemaknya!
FAQs Mengenai Node.js Cluster
Kelebihan utama menggunakan kluster Node.js adalah untuk meningkatkan prestasi aplikasi. Node.js berjalan pada benang, yang bermaksud ia hanya boleh menggunakan satu teras CPU pada satu masa. Walau bagaimanapun, pelayan moden biasanya mempunyai beberapa teras. Dengan menggunakan cluster Node.js, anda boleh membuat proses utama yang menghasilkan pelbagai proses pekerja, masing -masing berjalan pada teras CPU yang berbeza. Ini membolehkan permohonan anda memproses lebih banyak permintaan pada masa yang sama, yang meningkatkan kelajuan dan prestasinya dengan ketara.
node.js cluster berfungsi dengan mewujudkan proses utama yang menghasilkan pelbagai proses pekerja. Proses utama mendengarkan permintaan masuk dan mengedarkannya kepada proses pekerja dengan cara pengundian. Setiap proses pekerja berjalan pada teras CPU yang berasingan dan mengendalikan permintaan secara bebas. Ini membolehkan permohonan anda memanfaatkan semua teras CPU yang ada dan memproses lebih banyak permintaan pada masa yang sama.
Membuat cluster node.js melibatkan menggunakan modul "cluster" yang disediakan oleh Node.js. Pertama, anda perlu mengimport modul "kluster" dan "OS". Anda kemudian boleh menggunakan kaedah "cluster.fork ()" untuk membuat proses pekerja. "OS.CPUS (). Panjang" memberi anda bilangan teras CPU yang tersedia, yang boleh anda gunakan untuk menentukan bilangan proses pekerja untuk dicipta. Berikut adalah contoh mudah:
var cluster = require('cluster');Anda boleh mengendalikan kemalangan proses pekerja dalam kluster Node.js dengan mendengar peristiwa "keluar" pada proses utama. Apabila proses pekerja terhempas, ia menghantar acara "keluar" ke proses utama. Anda kemudian boleh menggunakan kaedah "cluster.fork ()" untuk membuat proses pekerja baru untuk menggantikan proses pekerja yang terhempas. Berikut adalah contoh:
if(cluster.isMaster) { ... }Ya, anda boleh menggunakan kluster Node.js dengan Express.js. Malah, menggunakan clustering Node.js dapat meningkatkan prestasi aplikasi Express.js. Anda hanya perlu meletakkan kod aplikasi Express.js dalam blok kod proses pekerja dalam skrip kluster.
Walaupun kluster Node.js dapat meningkatkan prestasi aplikasi dengan ketara, ia juga mempunyai beberapa batasan. Sebagai contoh, proses pekerja tidak berkongsi keadaan atau ingatan. Ini bermakna anda tidak boleh menyimpan data sesi dalam ingatan kerana ia tidak boleh diakses dalam semua proses pekerja. Sebaliknya, anda perlu menggunakan storan sesi bersama, seperti pangkalan data atau pelayan REDIS.
Secara lalai, proses utama dalam kluster Node.js mengedarkan permintaan masuk ke proses pekerja dengan cara pengundian. Ini memberikan bentuk asas pengimbangan beban. Walau bagaimanapun, jika anda memerlukan pengimbangan beban yang lebih maju, anda mungkin perlu menggunakan pelayan proksi terbalik, seperti nginx.
Ya, anda boleh menggunakan kluster Node.js dalam persekitaran pengeluaran. Malah, sangat disyorkan untuk menggunakan kelompok Node.js dalam persekitaran pengeluaran untuk memanfaatkan sepenuhnya teras CPU pelayan dan meningkatkan prestasi aplikasi anda.
Debugging node.js clusters boleh menjadi agak rumit kerana anda mempunyai beberapa proses pekerja yang berjalan pada masa yang sama. Walau bagaimanapun, anda boleh melampirkan debugger untuk setiap proses menggunakan bendera "periksa" dengan port unik untuk setiap proses pekerja. Berikut adalah contoh:
cluster.fork();
Ya, anda boleh menggunakan kluster Node.js dengan modul Node.js lain. Walau bagaimanapun, anda perlu ambil perhatian bahawa proses pekerja tidak berkongsi keadaan atau ingatan. Ini bermakna jika modul bergantung kepada keadaan bersama, ia mungkin tidak berfungsi dengan baik dalam persekitaran kluster.
Atas ialah kandungan terperinci Cara Membuat Kluster Node.js Untuk Mempercepatkan Aplikasi Anda. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
