Giải cứu Node.js khỏi 'Đơ' với worker_threads: Hóa giải tác vụ nặng!

Lê Lân

28/06/2025

Sử Dụng Worker_threads Trong Node.js Để Tăng Tốc Ứng Dụng Và Giải Quyết Tắc Nghẽn Route

Mở Đầu

Worker_threads trong Node.js mang đến giải pháp song song hóa xử lý JavaScript, giúp ứng dụng của bạn không bị tắc nghẽn trong những tác vụ tính toán nặng.

Trong phát triển backend với Node.js, xử lý các tác vụ tốn nhiều CPU như tính toán phức tạp rất dễ gây ra hiện tượng blocking event loop. Điều này làm cho các route khác trở nên không phản hồi, ảnh hưởng tiêu cực đến trải nghiệm người dùng. Bài viết này sẽ giới thiệu cách sử dụng module worker_threads để tận dụng đa luồng, cải thiện đáng kể hiệu năng và tránh giao diện bị đóng băng khi xử lý các tác vụ nặng.

Chúng ta sẽ cùng tìm hiểu từ lý thuyết, qua ví dụ thực tế xây dựng API đơn giản bằng framework Hono, cho đến cách chia nhỏ tác vụ và phân phối cho nhiều worker nhằm tối ưu tối đa đa nhân trên CPU.

1. Vấn Đề Tắc Nghẽn Trong Node.js Khi Xử Lý Tác Vụ Nặng

1.1 Node.js Và Event Loop

Node.js sử dụng cơ chế event loop đơn luồng để xử lý các tác vụ bất đồng bộ. Điều này giúp Node.js rất hiệu quả trong các I/O-bound tasks (tác vụ vào/ra), nhưng lại là điểm yếu lớn khi gặp các tác vụ CPU-bound (tính toán nặng).

1.2 Minh Họa Qua Ví Dụ API Với 2 Route

Route /: trả về "Hello, World!"

Route /compute: thực hiện phép tính nặng (tính tổng các số chẵn trong một mảng lớn gồm 100 triệu số ngẫu nhiên).

function calculate(amount) {
  return Array.from({ length: amount }, () => Math.floor(Math.random() * 1_000_000))
    .reduce((acc, num) => (num % 2 === 0 ? acc + num : acc), 0);
}

1.3 Hiện Tượng Blocking

Khi gửi yêu cầu đến /compute , máy chủ sẽ bận xử lý hàm calculate dẫn đến việc không thể phản hồi các request khác, ví dụ như / . Dưới đây là ảnh minh họa:

Điều này gây ra trải nghiệm người dùng tồi tệ và làm giảm hiệu suất của ứng dụng.

2. Giới Thiệu Về Worker_threads Trong Node.js

2.1 Khái Niệm Worker_threads

Worker_threads là module cho phép tạo ra các luồng (thread) độc lập thực thi JavaScript song song, mỗi luồng có vòng lặp sự kiện riêng.

2.2 Tại Sao Worker_threads Giúp Giải Quyết Vấn Đề?

Tính toán phức tạp được đẩy ra khỏi main thread.

Main thread vẫn hoạt động, xử lý các yêu cầu HTTP khác không bị gián đoạn.

Cho phép chia nhỏ tác vụ và xử lý đồng thời trên nhiều nhân CPU.

Lợi ích chính: Giữ cho API luôn phản hồi nhanh và cải thiện tổng thời gian thực thi các tác vụ phức tạp.

3. Thực Hành Worker_threads Với Ví Dụ API Hono

3.1 Tạo Worker Xử Lý Tính Toán Nặng (worker.js)

import { parentPort, workerData } from "worker_threads";

const numbers = Array.from({ length: workerData }, () => Math.floor(Math.random() * 1_000_000));
const result = numbers.reduce((acc, num) => (num % 2 === 0 ? acc + num : acc), 0);

parentPort.postMessage(result);

workerData : số lượng phần tử cần tính.

parentPort.postMessage(...) : gửi kết quả về luồng chính.

3.2 Cập Nhật Hàm calculate Trong main.js

import { Worker } from "worker_threads";

function calculate(amount) {
  return new Promise((resolve, reject) => {
    const worker = new Worker("./worker.js", { workerData: amount });
    worker.on("message", resolve);
    worker.on("error", reject);
  });
}

3.3 Thiết Lập Route /compute Gọi Worker

app.get("/compute", async (c) => {
  const result = await calculate(100_000_000);
  return c.text(`Result: ${result}`);
});

3.4 Kết Quả Sau Khi Áp Dụng Worker_threads

Route / phản hồi bình thường ngay cả khi tính toán đang diễn ra.

Tính toán hết khoảng 7.63 giây trên 1 worker.

Bạn hoàn toàn giải quyết được hiện tượng tắc nghẽn bằng cách sử dụng worker threads để tách biệt tác vụ CPU-heavy ra khỏi main event loop.

4. Tăng Tốc Hiệu Năng Bằng Cách Phân Mảnh Tác Vụ Và Chạy Nhiều Worker Song Song

4.1 Ý Tưởng Chia Nhiệm Vụ

Thay vì tính toán một lần 100 triệu số trong một worker, ta chia nhỏ ra thành 4 phần 25 triệu số:

Tạo 4 worker chạy đồng thời.

Lấy kết quả từng worker.

Tổng hợp lại.

4.2 Cập Nhật Route /compute

app.get("/compute", async (c) => {
  const results = await Promise.all([
    calculate(25_000_000),
    calculate(25_000_000),
    calculate(25_000_000),
    calculate(25_000_000),
  ]);
  const total = results.reduce((acc, num) => acc + num, 0);
  return c.text(`Result: ${total}`);
});

4.3 Kết Quả Cải Tiến

Thời gian tính toán giảm từ 7.63 giây xuống còn 1.56 giây.

Tận dụng được đa nhân của CPU để tăng tốc độ xử lý.

Phân mảnh và parallel hóa công việc cho phép ứng dụng không chỉ tránh tắc nghẽn mà còn tăng tổng hiệu suất tính toán.

Kết Luận

Sử dụng worker_threads trong Node.js là bước tiến quan trọng giúp:

Giữ cho ứng dụng luôn phản hồi nhanh ngay cả khi có những công việc tính toán nặng.

Tối ưu thời gian xử lý bằng cách tận dụng đa nhân CPU với nhiều luồng độc lập.

Cách làm này dễ áp dụng, giúp các ứng dụng backend cải thiện trải nghiệm người dùng và khả năng mở rộng.

Nếu bạn đang phát triển ứng dụng cần xử lý tác vụ nặng, hãy thử ngay worker_threads để giải quyết bottleneck và nâng cao hiệu năng tổng thể của hệ thống!

Tham Khảo

Node.js Documentation - worker_threads: https://nodejs.org/api/worker_threads.html

Hono Framework: https://hono.dev/

Blog Dev.to “Using Worker Threads in Node.js”: https://dev.to

"Understanding the Node.js Event Loop" - NodeSource Blog

V8 JavaScript Engine and Node.js Performance Guides