背景
在小米面试的时候被问到这个问题。一直以来都认为 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 来同时进行计算。
开启多进程后的潜在问题
- 因为每个进程的内存都是独立的，为了在多进程中共享数据，原来可能存储在内存中的数据，例如 token 等不能再存储在内存中，应该存储在 redis 等缓存中，以便保证不同的进程都可以访问该数据；
