Nodeのプロセスとスレッドの詳細な分析

スレッドとプロセスはコンピューター オペレーティング システムの基本概念であり、プログラマーの間でよく使われる言葉です。どのように理解すればよいでしょうか? Node.js のプロセスとスレッドはどうなるでしょうか?次の記事では、Node のプロセスとスレッドについて詳しく説明します。一定の参考値があるので、困っている友達が参考になれば幸いです。

#1. プロセスとスレッド

1.1. プロフェッショナル テキストの定義

プロセス (プロセス)、プロセスは、特定のデータ セット上でコンピュータ内のプログラムを実行するアクティビティです。システム内のリソース割り当てとスケジューリングの基本単位です。オペレーティング システム構造の基礎です。 process はスレッドのコンテナです。 [関連チュートリアルの推奨事項:
• nodejs ビデオ チュートリアル 、プログラミング教育 ]
スレッド (スレッド)、スレッドはオペレーティング システムが計算スケジュールを実行できる最小単位です。 「インプロセス」に含まれるのは、プロセス内の実際の営業単位です。

1.2. 一般的な理解

上記の説明は比較的難しいため、読んでも理解できない可能性があり、理解や記憶には役立ちません。 。簡単な例を見てみましょう:

あなたが、ある宅配便サイトに勤めているとします。最初、このサイトが担当するエリアにはあまり住民が多くなく、集荷をするのはあなただけです。パッケージ。 Zhang San の家に荷物を届け、Li Si の家に荷物を取りに行った後は、物事を 1 つずつ実行する必要があります。これは

シングル スレッドと呼ばれ、すべての作業は ## の順序で実行する必要があります。 ＃。 その後、このエリアにはさらに多くの住民が存在し、サイトはこのエリアに複数の兄弟と 1 人のチーム リーダーを割り当てました。より多くの住民にサービスを提供できます。これは マルチスレッド
と呼ばれ、チーム リーダーです。 メイン スレッド 、そしてすべての人が スレッド です。 宅配便の現場で使用される台車などのツールは現場が提供し、一人だけでなく全員が利用できるようにすることをマルチスレッドリソース共有と呼びます。
現在、サイト カートは 1 つだけであり、全員がそれを使用する必要があります。これは 競合
と呼ばれます。これを解決するには、列に並んで待ったり、他の人が終わってから通知を待ったりするなど、さまざまな方法がありますが、これを スレッド同期 と呼びます。

本社には多数の拠点があり、各拠点の運用モデルはほぼ同一であり、これを

マルチプロセス

と呼びます。本社を メインプロセス と呼び、各拠点を サブプロセス と呼びます。 本社と拠点間、および各拠点間ではカートが互いに独立しており、混在することができません。これを 工程間のリソース共有なし
といいます。各サイトは、パイプラインと呼ばれる電話やその他の方法を介して相互に通信できます。大規模なコンピューティング タスクの完了を容易にするために、サイト間のコラボレーションには他にも プロセス間同期 と呼ばれる手段があります。 Ruan Yifeng の

プロセスとスレッドの簡単な説明

も参照してください。

2. Node.js のプロセスとスレッド

Node.js は、シングルスレッド サービス、イベント駆動型、ノンブロッキング I/O モデル言語機能です。 , Node.js の作成は効率的かつ軽量です。利点は、頻繁なスレッド切り替えとリソースの競合を回避し、I/O 集中型の操作に優れていることです (基礎となるモジュール libuv は、マルチタスクを実行するために、マルチスレッドを介してオペレーティング システムによって提供される非同期 I/O 機能を呼び出します)。 , ただし、サーバー側の Node.js の場合、1 秒あたりに数百のリクエストを処理する必要がある可能性があり、CPU 集中型のリクエストに直面すると、シングルスレッド モードであるため、必然的にブロックが発生します。

2.1. Node.js のブロック

Koa を使用して Web サービスを単純​​に構築し、フィボナッチ数列メソッドを使用して Node.js の処理 CPU 集中型計算タスクをシミュレートします。 :

黄金分割数列としても知られるフィボナッチ数列。この数列は 3 番目の項目から始まり、各項目は前の 2 つの項目の合計に等しくなります: 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 回の計算に 617 ミリ秒かかったことがわかりました。つまり、CPU 集中型の計算タスクが実行されたため、Node.js のメイン スレッドが 600 ミリ秒以上ブロックされました。より多くのリクエストが同時に処理される場合、または計算タスクがより複雑な場合、これらのリクエスト以降のすべてのリクエストは遅延します。

複数のリクエストの送信をシミュレートするために新しい 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 個のワーカー プロセスが開始されたときの効果を見てみましょう:

所要時間はわずか 3 秒未満ですが、プロセスの数は無制限ではありません。日常の開発では、通常、ワーカー プロセスの数は CPU コアの数と同じになります。

2.5. マルチプロセスの説明

マルチプロセスを有効にすることは、完全に高い同時実行性に対処するためではなく、マルチコア CPU の使用率が不十分であるという問題を解決するためです。 Node.js。
fork メソッドを通じて親プロセスから派生した子プロセスは、親プロセスと同じリソースを持ちますが、独立しており、互いにリソースを共有しません。システム リソースには限りがあるため、プロセス数は通常、CPU コアの数に基づいて設定されます。

3. 概要

1. マルチスレッドによる CPU 集中型のコンピューティング タスクに対するソリューションのほとんどは、マルチプロセス ソリューションに置き換えることができます。 Node.js は非同期ですが、ブロックされないという意味ではありません。メイン スレッドのスムーズな流れを確保するために、メイン スレッドで CPU を集中的に使用するタスクを処理しないことが最善です;
3. 盲目的に追求しないでください高いパフォーマンスと高い同時実行性を備え、システムのニーズを満たします。ただし、プロジェクトに必要なのは効率と俊敏性であり、これは Node.js の軽量な特性でもあります。
4. Node.js には、I/O libuv の基盤となる Node.js、IPC 通信チャネルなど、記事内で言及されているものの詳細には説明されていない、または言及されていないプロセスやスレッドの概念が多数あります。プロセス間のリソースが共有されていない場合に、プロセスを保護する方法、スケジュールされたタスク、エージェント プロセスなどを処理する方法;
5. 上記のコードは、
https://github.com/liuxy0551/ で参照できます。ノードプロセススレッド。

ノード関連の知識の詳細については、

nodejs チュートリアル を参照してください。

以上がNodeのプロセスとスレッドの詳細な分析の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。