Bagaimana untuk melaksanakan nodejs multi-threading

Node.js ialah salah satu bahasa pengaturcaraan bahagian belakang yang lebih popular. Ciri I/O yang dipacu peristiwa dan tidak menyekat menjadikannya lebih cekap daripada bahasa lain.

Terutama apabila mencapai keselarasan tinggi, kelebihan I/O dipacu peristiwa dan tidak menyekat Node.js amat menonjol, yang boleh menyediakan kaedah berjalan yang lebih cekap untuk program kami.

Tetapi dalam sesetengah kes, mod larian satu-benang sebenarnya mungkin menjadi halangan yang tidak dapat diatasi, seperti semasa memproses tugasan intensif CPU, walaupun Node.js telah menggunakan model I/O tidak menyekat tak segerak untuk menyelesaikan I masalah /O-intensif dan mengurangkan kerumitan kod. Walau bagaimanapun, apabila menggunakan perpustakaan berbilang tugas seperti MPI, anda masih perlu melaksanakan penyelesaian berbilang benang. Walau bagaimanapun, model single-threading Node.js tidak menyokong multi-threading, jadi kaedah lain perlu digunakan untuk melaksanakan penyelesaian multi-threading.

Dalam artikel ini, kami akan memperkenalkan beberapa penyelesaian yang boleh anda gunakan untuk melaksanakan berbilang benang dalam Node.js, dan dalam keadaan apa ia paling berkesan.

1. Proses Kanak-kanak

Modul Proses Kanak-kanak dalam Node.js menyediakan cara untuk mencipta proses kanak-kanak dan melaksanakan pelbagai benang melalui proses kanak-kanak. Setiap proses kanak-kanak boleh melaksanakan dalam utasnya sendiri, dengan itu mengelakkan masalah menyekat dalam proses utama.

Menggunakan modul Proses Kanak-kanak, kami boleh melaksanakan beberapa tugasan intensif CPU dalam proses kanak-kanak, dan boleh memilih strategi yang berbeza untuk peruntukan tugasan dan interaksi data. Berikut ialah contoh menggunakan Proses Kanak-kanak untuk melaksanakan penambahan berbilang benang:

const { fork } = require('child_process');

// 创建子进程
const worker = fork('./worker');

// 向子进程发送数据
worker.send({a: 1, b: 2});

// 接收来自子进程的数据
worker.on('message', result => {
  console.log(result);
})

// 错误处理
worker.on('error', err => {
  console.log(err);
})

Dalam contoh ini, kami mula-mula menggunakan modul Proses Kanak-kanak untuk mencipta proses kanak-kanak, dan kemudian menghantar data kepada kanak-kanak melalui pekerja Kaedah .send() Proses, proses anak mengembalikan hasil kepada proses utama selepas melengkapkan pengiraan dan menerima nilai pulangan melalui kaedah worker.on('message'). Ini membolehkan pengiraan berbilang benang.

2. Benang Pekerja

Node.js menyediakan cara lain untuk melaksanakan berbilang benang: Benang Pekerja, yang membolehkan kami memulakan subbenang bebas daripada utas utama, Sub-benang ini boleh melakukan beberapa tugas yang memakan masa, dengan itu mengelakkan masalah menyekat utas utama dalam model satu-benang.

Tidak seperti Child Process, Worker Threads berkongsi memori sepenuhnya. Mereka boleh menjalankan kod JavaScript dalam persekitaran bebas tanpa perlu risau tentang perkongsian data.

Berikut ialah contoh menggunakan Benang Pekerja untuk melaksanakan penambahan berbilang benang:

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

function runService() {
  // 创建 Worker 线程
  const worker = new Worker(`
    const add = (a, b) => a + b;
    const { parentPort } = require('worker_threads');

    // 接收来自主线程的数据
    parentPort.on('message', message => {
      // 子线程执行加法运算
      const result = add(message.a, message.b);

      // 将结果发送给主线程
      parentPort.postMessage(result);
    });
  `);

  return worker;
}

// 启动 Worker 线程
const worker = runService();

// 向 Worker 线程发送数据
worker.postMessage({ a: 1, b: 2 });

// 接收来自 Worker 线程的数据
worker.on('message', result => {
  console.log(result);
});

// 错误处理
worker.on('error', err => {
  console.log(err);
});

Di sini, kami menggunakan Benang Pekerja untuk mencipta persekitaran subbenang bebas, yang menjalankan logik pengiraan Kami. Hantar data ke urutan anak melalui kaedah worker.postMessage() dan terima hasil pengiraan yang dikembalikan oleh urutan anak melalui kaedah worker.on('message'). Dengan cara ini kita mencapai pengkomputeran berbilang benang.

3. Kluster

Cara lain untuk melaksanakan multi-threading dalam Node.js ialah menggunakan modul Kluster Node.js. Modul Kluster mencapai pengimbangan beban dengan mengagihkan sambungan antara pelbagai proses Dalam erti kata lain, menggunakan berbilang proses boleh meningkatkan prestasi sistem dengan ketara apabila memproses tugas yang memakan masa.

Dalam sesetengah kes, modul Kluster mungkin lebih sesuai daripada Proses Kanak-kanak dan Benang Pekerja untuk mengendalikan isu selari data. Untuk menggunakan modul Kluster, anda perlu mengikuti langkah berikut:

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

if (cluster.isMaster) {
  // 获取 CPU 的核心数
  const numCPUs = require('os').cpus().length;

  // fork 子进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  // 处理 worker exit 事件
  cluster.on('exit', (worker, code, signal) => {
    console.info(`Worker ${worker.process.pid} died`);
  });
} else {
  const server = http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`hello world from ${process.pid}`);
  });

  server.listen(8000, () => {
    console.info(`Server running at http://localhost:8000/ in worker process with pid ${process.pid}`);
  });
}

Dalam contoh ini, kami mula-mula menentukan sama ada ia adalah proses utama Jika ya, kami menghentikan berbilang proses anak dan mendengar peristiwa keluar setiap proses kanak-kanak untuk memudahkan ralat Maklumkan proses utama untuk pemprosesan. Jika tidak, perkhidmatan HTTP dibuat dalam proses anak dan pid proses anak semasa ditentukan oleh parameter yang diluluskan dalam kaedah dengar.

Ringkasan

Di atas adalah tiga penyelesaian utama untuk melaksanakan multi-threading dalam Node.js, Child Process, Worker Threads dan Cluster Dua yang pertama lebih sesuai digunakan semasa memproses CPU-. tugasan intensif, dan yang kedua Yang terakhir ini lebih sesuai untuk penggunaan dan pengimbangan beban apabila mengendalikan tugas sambungan rangkaian. Sudah tentu, terdapat penyelesaian lain, seperti menggunakan Pekerja Web atau menggunakan perpustakaan C++ peringkat rendah untuk melaksanakan multi-threading, dsb.

Apabila menggunakan penyelesaian di atas, anda perlu memberi perhatian kepada beberapa butiran, seperti ketepatan data dan isu memori dikongsi, dsb., tetapi dengan bantuan penyelesaian ini, kami juga boleh menyediakan yang cekap dan berskala Aplikasi Node.js untuk prestasi yang lebih baik.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan nodejs multi-threading. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!