Tingkatkan Prestasi Pelayan Node.js dengan Benang Pekerja

Senario:

Sebelum kita menyelami urutan pekerja, mari kita pertimbangkan beberapa senario...

Andaikan pelanggan memuat naik fail besar ke pelayan yang perlu diubah suai atau melibatkan pemprosesan beribu-ribu titik data di latar belakang. Jika pelayan menunggu tugas ini selesai, pelanggan dibiarkan menunggu dan tidak dapat meneroka ciri lain. Bayangkan jika pelanggan terpaksa menunggu selama 5 minit tanpa dapat melakukan apa-apa lagi—ini akan mengecewakan dan jauh daripada mesra pengguna!

Pertimbangkan situasi lain di mana anda memuat naik imej profil, dan ia mengambil masa yang lama untuk memproses, menukar dan menyimpan dalam pangkalan data. Pada masa ini, jika pelayan menghalang anda daripada melaksanakan tugas lain, ia akan mengurangkan pengalaman pengguna dengan ketara.

Dalam kes pertama, bukankah lebih baik jika pelayan membenarkan anda meneroka ciri lain semasa fail masih diproses? Dengan cara ini, anda tidak perlu menunggu (kerana pelayan tidak akan menyekat anda), menghasilkan pengalaman yang lebih lancar.

Dalam kes kedua, bagaimana jika pemprosesan imej berlaku di latar belakang, membolehkan anda terus menggunakan ciri lain tanpa menunggu?

Penyelesaian:

Jadi, apakah cara yang berkesan untuk mengoptimumkan prestasi sistem dalam senario ini? Walaupun terdapat beberapa pendekatan, menggunakan benang pekerja adalah penyelesaian yang hebat. Urutan pekerja telah diperkenalkan dalam Node.js versi 10 dan amat berguna untuk melaksanakan tugas intensif CPU secara selari, mengurangkan beban pada CPU utama.
Benang pekerja beroperasi di latar belakang, mencipta benang berasingan yang mengendalikan pengiraan intensif tanpa menyekat utas utama, sekali gus membenarkan pelayan kekal responsif untuk tugasan lain. Walaupun JavaScript secara tradisinya adalah bahasa satu-utas dan Node.js beroperasi dalam persekitaran satu-utas, utas pekerja mendayakan multithreading dengan mengedarkan operasi merentas berbilang utas. Pelaksanaan selari ini mengoptimumkan penggunaan sumber dan mengurangkan masa pemprosesan dengan ketara.

Pelaksanaan worker_thread:

Hari ini kami akan melaksanakan aplikasi nodejs mudah dengan pakej lalai worker_threads . Mula-mula buat pelayan ekspres di mana permintaan get mudah dilaksanakan.

Mula-mula mulakan projek:

$ npm init -y

Pasang modul ekspres dan nodemon:

$ npm i express nodemon

Mencipta pelayan nodejs mudah yang berjalan pada port 3000.

Import express from ‘express’;
const app = express();
const port = 3000;


// Basic endpoint to test server
app.get(‘/’, (req, res) => {
   res.send(‘Hello World!’);
});


app.listen(port, () => console.log(`Server running on port ${port}`));

Di sini kami mencipta pelayan yang akan dijalankan pada port 3000.
Untuk menjalankan, mari kita ubah suai fail package.json kami.
Tambah jenis sebagai modul seperti di bawah untuk mendapatkan modul ES6. Ubah suai juga di bawah bahagian skrip seperti di bawah.

{
 "name": "worker_express",
 "version": "1.0.0",
 "description": "",
 "main": "index.js",
 "type": "module",
 "scripts": {
   "test": "echo \"Error: no test specified\" && exit 1",
   "start": "node index.js",
   "dev": "nodemon index.js"
 },
 "keywords": [],
 "author": "",
 "license": "ISC",
 "dependencies": {
   "dotenv": "^16.4.5",
   "express": "^4.19.2",
   "nodemon": "^3.1.4"
 }
}

Sekarang mari jalankan aplikasi kami sebagai mod dev dengan nodemon:

$ npm run dev

Anda akan melihat mesej Server berjalan pada port 3000. Sekarang pergi ke localhost:3000 dan anda boleh melihat Hello World! Setakat ini kami hanya melakukan pelayan ekspres nodejs yang mudah.

Sekarang mari buat fail lain bernama service.js
Di sini kita boleh mencipta fungsi jujukan fibonacci yang mencari jujukan fibonacci nombor ke-n.

// service.js
function fibonacci(n) {
   if (n <= 1) return 1;
   return fibonacci(n-1) + fibonacci(n-2);
}


export default fibonacci;

Sekarang mari tambah titik akhir api lain pada fail index.js dan panggil fungsi fibonacci daripada fail service.js. Kami akan mengira nombor Fibonacci ke-40 sebagai contoh.

import fibonacci from "./service.js";


// Fibonacci endpoint
app.get('/fibonacci', (req, res) => {
   fibonacci(40)
   res.send('fibonacci called');
})

Jika anda menekan URL http://localhost:3000/fibonacci, anda akan melihat bahawa ia melambatkan sedikit, membuatkan anda menunggu. Masa kelewatan bergantung pada pengiraan.

Anda boleh mencuba lagi dengan mengulas fungsi tersebut dan lihat ia mengambil masa yang lebih singkat iaitu kira-kira milisaat.

Dalam kes ini, anda mungkin perlu melakukan operasi berat lain yang memakan masa dan mengurangkan prestasi.

Dalam kes ini, kita boleh menggunakan modul worker_threads, yang telah tersedia secara lalai dalam Node.js sejak versi 10. Sekarang mari kita ubah suai kod untuk menggunakan worker_threads dan lihat kesannya.

Import Pekerja daripada worker_thread yang merupakan pakej lalai nod js.

import { Worker } from "worker_threads";

Sekarang ubah suai titik akhir api seperti di bawah.

// Endpoint using worker thread for CPU-intensive task
app.get('/fibonacci', (req, res) => {
   const worker = new Worker('./service.js', {workerData: 40});

   // Handle messages from worker thread
   worker.on('message', (resolve) => console.log(resolve));


   res.send('fibonacci called');
})

Di sini, kami mencipta contoh pekerja dan menetapkan nama fail service.js sebagai argumen pertama, manakala argumen kedua menghantar parameter melalui workerData. Anda boleh menukar parameter workerData kepada mana-mana data lain dan bukannya 40.

worker.on(‘message’, ….) This sets up an event listener on the worker for the ‘message’ event. The message event is emitted by the worker when it sends data back to the main thread using parentrPort.postMessage(...).
(resolve) => console.log(resolve) this is a callback function that will be executed when the worker sends back the data after operation. The received message(data) is passed to this function as the resolve parameter.

Now let’s update our service.js file.

import { workerData, parentPort } from 'worker_threads';


// Function to compute Fibonacci sequence
function fibonacci(n) {
   if (n <= 1) return 1;
   return fibonacci(n-1) + fibonacci(n-2);
}


// Compute Fibonacci using workerData
const fibonacciAt =  fibonacci(workerData);


// Send result back to the main thread
parentPort.postMessage(fibonacciAt);

Here, we import workerData and parentPort, which allow us to receive the data sent through workerData and return the result via the postMessage method of parentPort, both imported from worker_threads.

Test the Setup:
Now, send a request to http://localhost:3000/fibonacci and notice that the server no longer blocks the main thread. The time-consuming operation occurs in the background on a separate thread, significantly reducing the response time and improving user experience.

Here is the source code in github.

Atas ialah kandungan terperinci Tingkatkan Prestasi Pelayan Node.js dengan Benang Pekerja. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!