背景

在小米面试的时候被问到这个问题。一直以来都认为 Node.js 是只支持单线程。如果想开启多核支持的话，一般会在 PM2 中设置集群模式。所以，听到 Node.js 原生可以支持多线程的时候真的吃惊不小。

目标

Node.js 是否支持多线程；
Node.js 充分利用多核 CPU 的方式；

Node.js 是否支持多线程

查了很多资料，都是说 Node.js 只支持单线程。但是可以开启多进程充分利用多核 CPU。

Node.js 充分利用多核 CPU 的方式

开启多进程

如何开启多进程来充分利用多核 CPU 呢？首先需要一个测试用例，来验证开启多进程的前后效果。一开始想搭建服务器，然后做压力测试，因为没有怎么用过压力测试，还需要再单独学习压力测试的相关概念。为了聚焦问题，暂时就不使用压力测试的方式来验证，而采用了参考资料中的斐波那契数列计算作为测试用例。

测试用例

测试主要是要同时计算几个斐波那契数列，对比前后速度。因为我的个人电脑是双核四线程 CPU，相当于有 4 个逻辑核心。所以为了简化测试环境，用例就设置为计算 4 组斐波那契数列。

function fibonacci (n) {
  return n === 0
    ? 0
    : n === 1
      ? 1
      : fibonacci(n - 1) + fibonacci(n - 2)
}

不特意开启多进程支持的正常情况下

首先测试一下正常情况下，没有特意开启多进程支持情况下，4 个斐波那契数列的计算时间。

const seqArr = [44, 42, 43, 44]

function fibonacci (n) {
  return n === 0
    ? 0
    : n === 1
      ? 1
      : fibonacci(n - 1) + fibonacci(n - 2)
}

function calculate (seq, taskId) {
  return new Promise((resolve, reject) => {
    console.log(`Task ${taskId} starts calculating.`)
    const start = Date.now()
    const result = fibonacci(seq)
    console.log(`The result of task ${taskId} is ${result}, taking ${Date.now() - start} ms.`)
    return resolve(result)
  })
}

;(async function main () {
  console.time('main')
  const results = await Promise.all(seqArr.map(calculate))
  results.forEach((result, index) => console.log(`Task ${index}'s result is ${result}`))
  console.timeEnd('main')
})()

将每个计算的过程都封装成一个 Promise 实例，然后使用 Promise.all() 方法希望 4 个斐波那契数列计算能够并发执行。

测试结果为：

Task 0 starts calculating.
The result of task 0 is 701408733, taking 9411 ms.
Task 1 starts calculating.
The result of task 1 is 267914296, taking 3544 ms.
Task 2 starts calculating.
The result of task 2 is 433494437, taking 5784 ms.
Task 3 starts calculating.
The result of task 3 is 701408733, taking 9316 ms.
Task 0's result is 701408733
Task 1's result is 267914296
Task 2's result is 433494437
Task 3's result is 701408733
main: 28058.304ms

根据结果来看，很明显是顺序执行的，当然最终的计算时间也几乎等于四组斐波那契数列的计算时间的和。

Node.js 原生的 cluster

然后再来测试一下使用了 Node.js 原生 cluster 的执行效果。

const cluster = require('cluster')
const numCPUs = require('os').cpus().length

function fibonacci (n) {
  return n === 0
    ? 0
    : n === 1
      ? 1
      : fibonacci(n - 1) + fibonacci(n - 2)
}

if (cluster.isMaster) {
  const seqArr = [44, 42, 43, 44]
  let endTaskNum = 0

  console.time('main')
  console.log(`[Master]# Master starts running. pid: ${process.pid}`)

  for (let i = 0; i < numCPUs; i++) {
    const worker = cluster.fork()
    worker.send(seqArr[i])
  }
  cluster.on('message', (worker, message, handle) => {
    console.log(`[Master]# Worker ${worker.id}: ${message}`)
    endTaskNum++
    if (endTaskNum === 4) {
      console.timeEnd('main')
      cluster.disconnect()
    }
  })
  cluster.on('exit', (worker, code, signal) => console.log(`[Master]# Worker ${worker.id} died.`))
} else {
  process.on('message', seq => {
    console.log(`[Worker]# starts calculating...`)
    const start = Date.now()
    const result = fibonacci(seq)
    console.log(`[Worker]# The result of task ${process.pid} is ${result}, taking ${Date.now() - start} ms.`)
    process.send('My task has ended.')
  })
}

[Master]# Master starts running. pid: 1417
[Worker]# starts calculating...
[Worker]# starts calculating...
[Worker]# starts calculating...
[Worker]# starts calculating...
[Worker]# The result of task 1419 is 267914296, taking 6966 ms.
[Master]# Worker 2: My task has ended.
[Worker]# The result of task 1420 is 433494437, taking 11015 ms.
[Master]# Worker 3: My task has ended.
[Worker]# The result of task 1418 is 701408733, taking 14559 ms.
[Master]# Worker 1: My task has ended.
[Worker]# The result of task 1421 is 701408733, taking 14691 ms.
[Master]# Worker 4: My task has ended.
main: 14868.557ms
[Master]# Worker 2 died.
[Master]# Worker 3 died.
[Master]# Worker 4 died.
[Master]# Worker 1 died.

从结果可以看出，四组数列同时开始计算，而整个计算时间，也基本等同于最长的一个数列的计算时间。这说明我们已经开了 4 个进程充分利用了四核 CPU 来同时进行计算。