Pengelompokan dan Benang Pekerja - Node JS

Dalam artikel sebelumnya " Node JS Internals " kami membincangkan seni bina dalaman Node JS dan juga membincangkan mengapa kami perlu meningkatkan saiz Thread Pool untuk mengendalikan berbilang permintaan serentak. Saya telah memberitahu anda bahawa kebolehskalaan dan prestasi tidak berkaitan dengan saiz Kolam Benang.

Untuk kebolehskalaan dan prestasi tinggi, kami boleh menggunakan pengelompokan dan benang pekerja.

Pengelompokan

Katakan anda berada dalam majlis perkahwinan yang besar dan beribu-ribu tetamu berada dalam majlis perkahwinan itu. Terdapat satu dapur dan seorang tukang masak sedang menyediakan makanan untuk semua tetamu ini. Kedengaran tidak dapat diramalkan, bukan? Anda tidak menggunakan sumber dapur sepenuhnya jika anda hanya mempunyai seorang tukang masak.

Inilah yang berlaku dalam aplikasi Node JS yang dijalankan pada CPU berbilang teras apabila hanya satu teras digunakan untuk mengendalikan semua permintaan. jadi, walaupun mesin kami mempunyai kuasa berbilang teras, tanpa pengelompokan, aplikasi kami berjalan pada satu teras sahaja. Satu teras bertanggungjawab untuk mengendalikan semua kerja.

Apabila di dapur anda berbilang tukang masak bekerja, itulah kumpulannya.

Pengkelompokan ialah teknik yang digunakan untuk membolehkan aplikasi Node JS tunggal menggunakan berbilang teras CPU dengan berkesan.

Untuk melaksanakan pengelompokan, anda perlu menggunakan modul kelompok daripada Node JS.

const cluster = require('cluster');

Dengan menggunakan modul kluster ini, anda boleh membuat berbilang kejadian aplikasi Node JS kami. Keadaan ini dipanggil pekerja. Semua pekerja berkongsi port pelayan yang sama dan mengendalikan permintaan masuk secara serentak.

Terdapat dua jenis proses dalam seni bina kelompok.

1. Proses Induk:

Proses Master adalah seperti tukang masak utama di dapur yang menguruskan pekerja. Ia memulakan aplikasi, menyediakan persekitaran pengelompokan, dan juga mewakilkan tugas kepada proses pekerja. Ia tidak secara langsung mengendalikan permintaan aplikasi.

Apakah yang dilakukan oleh proses Master?

• Mencipta berbilang proses pekerja menggunakan kaedah cluster.fork(). Ia juga memulakan semula pekerja jika mereka ranap atau keluar secara tidak dijangka.

• Ia memastikan permintaan masuk diedarkan merentas semua proses pekerja. Di Linux, ini dikendalikan oleh sistem pengendalian dan pada Windows, Node JS sendiri bertindak sebagai pengimbang beban.

• Ia membolehkan komunikasi antara pekerja melalui IPC(Komunikasi Antara Proses).

2. Proses Pekerja:

Proses pekerja ialah contoh aplikasi Node JS yang dibuat oleh proses induk. Setiap proses berjalan secara berasingan pada teras CPU yang berasingan dan mengendalikan permintaan masuk.

Proses pekerja tidak boleh berkomunikasi secara langsung antara satu sama lain mereka berkomunikasi melalui induk.

Proses pekerja mengendalikan permintaan masuk dan melaksanakan beberapa tugas seperti pertanyaan pangkalan data, pengiraan atau sebarang logik aplikasi.

const cluster = require('cluster');

Di sini, kami menyemak dahulu ini adalah proses induk. jika ya maka ia akan mewujudkan proses pekerja.

Dalam kod kami, saya sedang mencipta proses pekerja menggunakan cluster.fork().

Tetapi, ini bukan cara yang ideal untuk mencipta proses pekerja.

Andaikan, anda sedang mencipta 4 proses pekerja dan sistem anda mempunyai dua teras.

Untuk menyelesaikan masalah ini dan bukannya mencipta proses pekerja berkod tegar, mula-mula cari teras CPU kemudian pertimbangkan bahawa data mencipta proses pekerja.

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // Fork workers
    cluster.fork();
    cluster.fork();
    cluster.fork();
    cluster.fork();

} else {
  console.log(`Worker ${process.pid} is running`);
  // Worker logic (e.g., server setup) goes here
}

Saya menggunakan sistem dwi teras jadi output akan kelihatan seperti ini.

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
  const numCPUs = os.cpus().length;

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  console.log(`Worker ${process.pid} is running`);
  // Worker logic (e.g., server setup) goes here
}

Sekarang, anda mempunyai soalan jika anda mempunyai CPU dwi-teras maka mengapa 4 proses pekerja dibuat?

Ini kerana bilangan teras logik ialah 4, CPU saya menyokong hyperthreading atau Simultaneous Multi-Threading (SMT).

Benang Pekerja

Di restoran, pelayan mengambil pesanan dan memberikan pesanan itu kepada pasukan tukang masak kerana memasak mengambil sedikit masa. Jika pembersihan meja atau apa-apa kerja berkaitan pelayan datang maka pelayan melakukan ini. Apabila pesanan telah siap tukang masak memberikan semula makanan kepada pelayan dan pelayan menghidangkan makanan ini kepada pelanggan.

Ini adalah senario yang sama berkaitan dengan rangkaian pekerja. Jika sebarang tugasan yang mahal secara pengiraan seperti pemprosesan data berskala besar, pengiraan kompleks atau algoritma berat datang, maka utas utama mewakilkan tugas ini kepada utas pekerja. Pekerja melaksanakan tugas ini, bukan urutan utama.

*Mengapa, ini membantu? *

Kami tahu bahawa gelung acara Node JS adalah satu-benang dan jika kerja pengiraan berat ini dilakukan oleh utas utama maka gelung acara akan disekat. Jika anda menggunakan utas pekerja ini maka tugas berat ini diberikan kepada utas pekerja dan utas pekerja melaksanakan tugas ini, bukan utas utama supaya gelung acara tidak disekat.

Benang pekerja boleh berkomunikasi dengan utas utama melalui sistem penghantaran mesej dan data boleh dihantar antara utas menggunakan pengklonan berstruktur (salinan dalam).

Kini, kami cuba meniru urutan pekerja yang berfungsi.

main.js (Benang Utama)

Master 12345 is running
Worker 12346 is running
Worker 12347 is running
Worker 12348 is running
Worker 12349 is running

worker.js (Benang Pekerja)

const { Worker } = require('worker_threads');

function startWorker() {
  const worker = new Worker('./worker.js'); // Create a worker using worker.js

  // Listen for messages from the worker
  worker.on('message', (message) => {
    console.log('Message from worker:', message);
  });

  // Handle errors in the worker
  worker.on('error', (error) => {
    console.error('Worker error:', error);
  });

  // Handle worker exit
  worker.on('exit', (code) => {
    console.log(`Worker exited with code ${code}`);
  });

  // Send a message to the worker
  worker.postMessage({ num: 100 });
}

startWorker();

Jika data mengandungi struktur yang besar, ia akan diklon secara mendalam dan diluluskan, yang mungkin mempunyai beberapa overhed prestasi.

Menggunakan kod

• Kelas Pekerja digunakan untuk menghasilkan benang baharu.

• Anda boleh menghantar data kepada pekerja menggunakan worker.postMessage dan mendengar mesej dengan worker.on('message', callback).

• Dalam urutan pekerja, parentPort ialah antara muka utama untuk berkomunikasi dengan utas utama.

• Anda boleh mendengar mesej daripada utas utama (parentPort.on('message')) dan menghantar semula mesej menggunakan parentPort.postMessage.

Outputnya ialah:

const cluster = require('cluster');

Sekarang, anda juga mempunyai satu soalan: mengapa kita tidak mencipta ratusan rangkaian pekerja?

Tetapi, Sebabnya ialah jika anda mencipta lebih banyak utas daripada bilangan teras, utas akan bersaing untuk masa CPU, yang membawa kepada penukaran konteks, yang mahal dan mengurangkan prestasi keseluruhan.

Bilakah anda harus menggunakan pengelompokan, urutan pekerja atau kedua-duanya dalam Node.js?

1. Bila hendak menggunakan benang Pekerja?

• Tugas Terikat CPU:

Tugas melibatkan pengiraan berat, seperti pemprosesan Imej/video, Pemampatan data atau penyulitan, Inferens pembelajaran mesin, Pengiraan saintifik

• Memori Dikongsi diperlukan:

Anda perlu berkongsi data dengan cekap antara urutan tanpa menduplikasinya.

• Penggunaan teras tunggal:

Jika aplikasi anda perlu menskalakan hanya dalam satu proses tetapi masih memerlukan keselarian untuk tugas intensif CPU.

2. Bila hendak menggunakan pengelompokan?

• I/O terikat:

Tugas melibatkan pengendalian jumlah permintaan pelanggan yang tinggi, seperti Web, pelayan, aplikasi Sembang dan API. Pengelompokan membantu menskalakan secara mendatar dengan mengedarkan permintaan merentas semua teras CPU.

• Memori terpencil:

Aplikasi anda tidak perlu berkongsi banyak data antara proses.

• Penggunaan Berbilang Teras:

Anda mahu menggunakan semua teras yang tersedia dengan melahirkan berbilang proses Node.js.

3. Bila hendak menggunakan kedua-dua pengelompokan dan benang pekerja?

• Tugas Terikat CPU I/O-Terikat:

Aplikasi mengendalikan permintaan HTTP tetapi memunggah tugasan intensif secara pengiraan. Contoh: Pelayan web memproses muat naik fail dan melakukan saiz semula imej atau transkod video.

• Skala Tinggi:

Anda memerlukan kedua-dua tahap proses dan tahap benang selari untuk pemprosesan yang tinggi. Dalam tapak E-dagang Pengkelompokan memastikan pelbagai proses mengendalikan permintaan masuk. Urutan pekerja memproses tugas latar belakang seperti menjana pengesyoran diperibadikan.

Terima Kasih.

Sila ajukan soalan atau berikan sebarang cadangan.

Jika anda menjumpai maklumat ini, sukakannya.

Atas ialah kandungan terperinci Pengelompokan dan Benang Pekerja - Node JS. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!