行程和執行緒如何理解？ Node.js中的行程和執行緒是怎麼樣的？

線程和進程是電腦作業系統的基礎概念，在程式設計師中屬於高頻詞彙，那該如何理解呢？ Node中的行程和執行緒又是怎麼樣的呢？下面這篇文章就來一起了解一下，希望對大家有幫助！

一、進程與執行緒

1.1、專業性文字定義

• 程式（Process ），進程是電腦中的程式關於某資料集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是作業系統結構的基礎，進程是執行緒的容器。
• 執行緒（Thread），執行緒是作業系統能夠進行運算調度的最小單位，被包含在進程之中，是進程中的實際運作單位。

1.2、通俗理解

以上描述比較硬，看完可能也沒看懂，還不利於理解記憶。那我們舉個簡單的例子：

假設你是某個快遞站點的小哥，起初這個站點負責的區域住戶不多，收取件都是你一個人。給張三家送完件，再去李四家取件，事情得一件件做，這叫單線程，所有的工作都得按順序執行。

後來這個區域住戶多了，站點給這個區域分配了多個小哥，還有個小組長，你們可以為更多的住戶服務了，這叫多線程 ，小組長是主執行緒，每個小哥都是一個執行緒。

快遞站點使用的小推車等工具，是站點提供的，小哥們都可以使用，並不僅供某一個人，這叫多線程資源共享。

站點小推車目前只有一個，大家都需要使用，這叫衝突。解決的方法有很多，排隊等待或等其他小哥用完後的通知，這叫做線程同步。

總公司有很多站點，各個站點的營運模式幾乎一模一樣，這叫多進程。總公司叫主程序，各個站台叫子程序。
總公司和站點之間，以及各個站點互相之間，小推車都是相互獨立的，不能混用，這叫進程間不共享資源。各站點間可以透過電話等方式聯繫，這叫管道。各站點間還有其他協同手段，方便完成更大的運算任務，這叫做進程間同步。

也可以看看阮一峰的 進程與執行緒的一個簡單解釋。

二、Node.js 中的行程和執行緒

Node.js 是單執行緒服務，事件驅動與非阻塞I/O模型的語言特性，使得Node.js 有效率且輕量。優點在於免去了頻繁切換執行緒和資源衝突；擅長I/O 密集型操作（底層模組libuv 透過多執行緒呼叫作業系統提供的非同步I/O 能力進行多任務的執行），但對於服務端的Node.js ，可能每秒有上百個請求需要處理，當面對CPU 密集型請求時，因為是單執行緒模式，難免會造成阻塞。

2.1、Node.js 阻斷

我們利用Koa 簡單地建立一個Web 服務，用斐波那契數列方法來模擬Node.js 處理CPU 密集型的計算任務：

斐波那契數列，也稱為黃金分割數列，這個數列從第三項開始，每一項都等於前兩項只和：0、1、1、2、 3、5、8、13、21、......

// app.js
const Koa = require('koa')
const router = require('koa-router')()
const app = new Koa()

// 用来测试是否被阻塞
router.get('/test', (ctx) => {
    ctx.body = {
        pid: process.pid,
        msg: 'Hello World'
    }
})
router.get('/fibo', (ctx) => {
    const { num = 38 } = ctx.query
    const start = Date.now()
    // 斐波那契数列
    const fibo = (n) => {
        return n > 1 ? fibo(n - 1) + fibo(n - 2) : 1
    }
    fibo(num)

    ctx.body = {
        pid: process.pid,
        duration: Date.now() - start
    }
})

app.use(router.routes())
app.listen(9000, () => {
    console.log('Server is running on 9000')
})

執行node app.js 啟動服務，用Postman 發送請求，可以看到，計算38 次耗費了617ms，換而言之，因為執行了一個CPU 密集的運算任務，所以Node.js 主執行緒被阻塞了六百多毫秒。如果同時處理更多的請求，或者計算任務更複雜，那麼在這些請求之後的所有請求都會被延遲執行。

我們再新建一個axios.js 用來模擬發送多次請求，此時將app.js 中的fibo 計算次數改為43 ，用來模擬更複雜的計算任務：

// axios.js
const axios = require('axios')

const start = Date.now()
const fn = (url) => {
    axios.get(`http://127.0.0.1:9000/${ url }`).then((res) => {
        console.log(res.data, `耗时: ${ Date.now() - start }ms`)
    })
}

fn('test')
fn('fibo?num=43')
fn('test')

#可以看到，當請求需要執行CPU 密集型的計算任務時，後續的請求都被阻塞等待，這類請求一多，服務基本上就阻塞卡死了。對於這種不足，Node.js 一直在彌補。

2.2、master-worker

master-worker 模式是一种并行模式，核心思想是：系统有两个及以上的进程或线程协同工作时，master 负责接收和分配并整合任务，worker 负责处理任务。

2.3、多线程

线程是 CPU 调度的一个基本单位，只能同时执行一个线程的任务，同一个线程也只能被一个 CPU 调用。如果使用的是多核 CPU，那么将无法充分利用 CPU 的性能。

多线程带给我们灵活的编程方式，但是需要学习更多的 Api 知识，在编写更多代码的同时也存在着更多的风险，线程的切换和锁也会增加系统资源的开销。

• worker_threads 工作线程，给 Node.js 提供了真正的多线程能力。

worker_threads 是 Node.js 提供的一种多线程 Api。对于执行 CPU 密集型的计算任务很有用，对 I/O 密集型的操作帮助不大，因为 Node.js 内置的异步 I/O 操作比 worker_threads 更高效。worker_threads 中的 Worker，parentPort 主要用于子线程和主线程的消息交互。

将 app.js 稍微改动下，将 CPU 密集型的计算任务交给子线程计算：

// app.js
const Koa = require('koa')
const router = require('koa-router')()
const { Worker } = require('worker_threads')
const app = new Koa()

// 用来测试是否被阻塞
router.get('/test', (ctx) => {
    ctx.body = {
        pid: process.pid,
        msg: 'Hello World'
    }
})
router.get('/fibo', async (ctx) => {
    const { num = 38 } = ctx.query
    ctx.body = await asyncFibo(num)
})

const asyncFibo = (num) => {
    return new Promise((resolve, reject) => {
        // 创建 worker 线程并传递数据
        const worker = new Worker('./fibo.js', { workerData: { num } })
        // 主线程监听子线程发送的消息
        worker.on('message', resolve)
        worker.on('error', reject)
        worker.on('exit', (code) => {
            if (code !== 0) reject(new Error(`Worker stopped with exit code ${code}`))
        })
    })
}

app.use(router.routes())
app.listen(9000, () => {
    console.log('Server is running on 9000')
})

新增 fibo.js 文件，用来处理复杂计算任务：

const { workerData, parentPort } = require('worker_threads')
const { num } = workerData

const start = Date.now()
// 斐波那契数列
const fibo = (n) => {
    return n > 1 ? fibo(n - 1) + fibo(n - 2) : 1
}
fibo(num)

parentPort.postMessage({
    pid: process.pid,
    duration: Date.now() - start
})

执行上文的 axios.js，此时将 app.js 中的 fibo 计算次数改为 43，用来模拟更复杂的计算任务：

可以看到，将 CPU 密集型的计算任务交给子线程处理时，主线程不再被阻塞，只需等待子线程处理完成后，主线程接收子线程返回的结果即可，其他请求不再受影响。
上述代码是演示创建 worker 线程的过程和效果，实际开发中，请使用线程池来代替上述操作，因为频繁创建线程也会有资源的开销。

线程是 CPU 调度的一个基本单位，只能同时执行一个线程的任务，同一个线程也只能被一个 CPU 调用。

我们再回味下，本小节开头提到的线程和 CPU 的描述，此时由于是新的线程，可以在其他 CPU 核心上执行，可以更充分的利用多核 CPU。

2.4、多进程

Node.js 为了能充分利用 CPU 的多核能力，提供了 cluster 模块，cluster 可以通过一个父进程管理多个子进程的方式来实现集群的功能。

• child_process 子进程，衍生新的 Node.js 进程并使用建立的 IPC 通信通道调用指定的模块。
• cluster 集群，可以创建共享服务器端口的子进程，工作进程使用 child_process 的 fork 方法衍生。

cluster 底层就是 child_process，master 进程做总控，启动 1 个 agent 进程和 n 个 worker 进程，agent 进程处理一些公共事务，比如日志等；worker 进程使用建立的 IPC（Inter-Process Communication）通信通道和 master 进程通信，和 master 进程共享服务端口。

新增 fibo-10.js，模拟发送 10 次请求：

// fibo-10.js
const axios = require('axios')

const url = `http://127.0.0.1:9000/fibo?num=38`
const start = Date.now()

for (let i = 0; i  {
        console.log(res.data, `耗时: ${ Date.now() - start }ms`)
    })
}

可以看到，只使用了一个进程，10 个请求慢慢阻塞，累计耗时 15 秒：

接下来，将 app.js 稍微改动下，引入 cluster 模块：

// app.js
const cluster = require('cluster')
const http = require('http')
const numCPUs = require('os').cpus().length
// const numCPUs = 10 // worker 进程的数量一般和 CPU 核心数相同
const Koa = require('koa')
const router = require('koa-router')()
const app = new Koa()

// 用来测试是否被阻塞
router.get('/test', (ctx) => {
    ctx.body = {
        pid: process.pid,
        msg: 'Hello World'
    }
})
router.get('/fibo', (ctx) => {
    const { num = 38 } = ctx.query
    const start = Date.now()
    // 斐波那契数列
    const fibo = (n) => {
        return n > 1 ? fibo(n - 1) + fibo(n - 2) : 1
    }
    fibo(num)

    ctx.body = {
        pid: process.pid,
        duration: Date.now() - start
    }
})
app.use(router.routes())

if (cluster.isMaster) {
    console.log(`Master ${process.pid} is running`)
    
    // 衍生 worker 进程
    for (let i = 0; i  {
        console.log(`worker ${worker.process.pid} died`)
    })
} else {
    app.listen(9000)
    console.log(`Worker ${process.pid} started`)
}

执行 node app.js 启动服务，可以看到，cluster 帮我们创建了 1 个 master 进程和 4 个 worker 进程：

通过 fibo-10.js  模拟发送 10 次请求，可以看到，四个进程处理 10 个请求耗时近 9 秒：

当启动 10 个 worker 进程时，看看效果：

只需不到 3 秒，不過進程的數量也不是無限的。在日常開發中，worker 進程的數量一般和 CPU 核心數相同。

2.5、多進程說明

開啟多進程不全是為了處理高並發，而是為了解決 Node.js 對於多核心 CPU 使用率不足的問題。
由父進程透過 fork 方法衍生出來的子進程擁有和父進程一樣的資源，但是各自獨立，互相之間資源不共享。通常根據 CPU 核心數來設定進程數量，因為系統資源是有限的。

三、總結

1、大部分透過多執行緒解決CPU 密集型運算任務的方案都可以透過多進程方案來取代；
2、 Node.js 雖然異步，但不代表不會阻塞，CPU 密集型任務最好不要在主線程處理，保證主線程的暢通；
3、不要一味的追求高性能和高並發，達到系統需要即可，高效、敏捷才是專案需要的，這也是Node.js 輕量的特色。
4、Node.js 中的進程和執行緒還有很多概念在文章中提到了但沒展開細講或沒提到的，例如：Node.js 底層I/O 的libuv、IPC 通訊通道、多進程如何守護、進程間資源不共享如何處理定時任務、agent 進程等；
5、以上程式碼可在https://github.com/liuxy0551/node-process-thread 查看。

更多node相關知識，請造訪：nodejs 教學！

以上是行程和執行緒如何理解？ Node.js中的行程和執行緒是怎麼樣的？的詳細內容。更多資訊請關注PHP中文網其他相關文章！