※本記事はアフィリエイト広告(PR)を含みます。
たまにだけ数が合わないのは、競合状態です。プロセスとスレッドの違いを押さえ、実際にずれを起こして確かめます。
前回: PとNP・NP完全 — 答え合わせは一瞬なのに解けない
これは【深掘り】の記事です。本線の順路ではありません。 このシリーズは言葉を覚える回にしません。 全部、手元で書いて、走らせて、数字を出します。 飛ばしても本線は進めます。 本線側の「プロセスとは何か」は startとenableは別物 — サーバーが「動いている」とは何か にあります。
この記事のコマンドは、VMの中(Ubuntu Server)で打ちます。 Windows の PowerShell ではありません。VM の立て方は VMを29台溜めた話 — Ubuntu Serverの立て方 にあります。
先に VM の CPU コア数を確認してください。 この記事の実験は、コアが1つしかないVMだと半分が成立しません。 「同時に走る」ことが前提の話なので、コアが1つだとそもそも同時に走らないからです。 確認と増やし方は ① でやります。2コア以上にしてから読み進めてください。
「並列にすれば速くなる」と思っていました。
集計処理が遅かったので、4つのワーカーに割って走らせるようにしました。速くはなりました。
でも、たまに合計が合いませんでした。
最初は「入力データがおかしいのだろう」と思いました。ログを足しました。ログを足すと再現しなくなりました。 消すとまた出ました。10回走らせて、9回は正しくて、1回だけ違う。しかも毎回違う数字が出ます。
この時点で私は「メモリが壊れているのでは」まで疑いました。違いました。
同じメモリを、複数のスレッドが同時に書き換えていました。
x = x + 1は、1つの動作ではありません。「読む」「足す」「書く」の3つです。 その途中で横取りされると、誰かの1回分が消えます。
この記事では、この現象を実際に起こします。 走らせるたびに違う数が出るところと、 たまに正解が出てしまうところまで、そのまま出します。「たまにしか再現しないバグ」の正体はこれです。
そして直します。さらに、直すために使ったロックが、今度は別の壊れ方(デッドロック)をするところまでやります。
対象レベル: 中級〜上級 / 区分: 発展
この記事でわかること
- プロセスとスレッドの違いは、突き詰めると「メモリを分けるか、共有するか」の1点。他は全部そこから出てくる
x = x + 1は3つの動作。だから途中で横取りされて、数が減る- 競合状態は「たまに正解する」。だからテストで見つからず、ログを足すと消える
- 並列にしても、コア数の倍数だけ速くはならない。起動と待ち合わせの分が必ず引かれる
- ミューテックスは「同時に1人」のセマフォ。セマフォは人数を決めるもので、DBのコネクション上限と同じ形
- デッドロックの直し方は「ロックを取る順番を全体で1つに決める」。4条件のうち1つ崩せば止まらない
- CPUは1コアで1つしか実行していない。速く見えるのは切り替えているだけ
psの RSS を全部足すと実メモリを超える。共有分を人数分数えているから- Node.js では、まず非同期で足りる。ワーカーが要るのはCPUを使う仕事だけ
この記事でやること
- VMのコア数を確認し、足りなければ増やす
ps -eLfで、プロセスとスレッドの両方を1画面に出して違いを見るchild_process.forkとworker_threadsで同じ計算を並列にし、起動と通信のコストを実測するSharedArrayBufferで競合状態をわざと起こし、Atomics.addで直すAtomics.wait/Atomics.notifyでミューテックスとセマフォを自作する- ロックの順番を逆にしてデッドロックを起こし、タイムアウトで安全に抜ける
vmstat/nice/topでスケジューリングを目で見るfree -h//proc/meminfo/dmesgで仮想メモリの読み方を確かめる
先に知る言葉
この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。
| 言葉 | 意味 |
|---|---|
| プロセス | 実行中のプログラム1つ。自分専用のメモリ空間を持つ |
| スレッド | プロセスの中の実行の流れ。同じプロセスのスレッドはメモリを共有する |
| 競合状態(レースコンディション) | 複数の実行の流れが同じ場所を同時に触って、順番次第で結果が変わること |
| 不可分(アトミック) | 途中で割り込まれないこと。「読む→足す→書く」を1手でやる |
| ミューテックス | 「同時に1人だけ」を保証する鍵。mutual exclusion(相互排除) の略 |
| セマフォ | 同時に入れる人数を決める鍵。人数を1にするとミューテックス |
| デッドロック | お互いが相手の持っている鍵を待って、永久に動かなくなること |
| コンテキストスイッチ | CPUが実行するものを切り替えること。切り替え自体にも時間がかかる |
| 仮想メモリ | 各プロセスが「メモリを全部自分が持っている」と思い込める仕組み |
| ページング | メモリを固定サイズ(通常4KB)のページに区切って管理すること |
① 環境を確認する — コアが1つだと実験にならない
まず VM のコア数を見ます。
4
ここが 1 だった人は、先に VM の設定を変えてください。 VMware Workstation の「仮想マシン設定 → プロセッサ」で、「プロセッサコアの総数」を 2 以上にします (VMを一度シャットダウンしてから変更します)。1コアのままだと、この記事の③④⑦は差が出ません。
もう少し詳しく見ます。
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 4
On-line CPU(s) list: 0-3
Vendor ID: GenuineIntel
Model name: 12th Gen Intel(R) Core(TM) i7-12700H
Thread(s) per core: 1
Core(s) per socket: 2
Socket(s): 2
読むのは3行だけです。
| 行 | 意味 |
|---|---|
CPU(s): 4 | OSから見える実行単位が4つ。同時に4つまで本当に走る |
On-line CPU(s) list: 0-3 | 番号は0から。taskset などで指定するときに使う |
Thread(s) per core: 1 | 1コアあたりのハードウェアスレッド数。2ならハイパースレッディング有効 |
「CPU(s): 4」は「4つ同時に走る」ということであって、「4倍速くなる」ではありません。 そこは③で測ります。
Node.js が入っているかも確認します。
v22.14.0
node が無ければ sudo apt install -y nodejs npm で入れてから進めてください。
作業場所を作ります。最後に消します。
/home/user/cslab/proc
📸 スクリーンショット1:
nprocとlscpu | head -20の出力。CPU(s):の行が2以上になっていることを残す
手元のPCに余裕がなく、VMのコア数を増やせない場合は、複数コアのVPSを借りて試す方法もあります。さくらのVPS
は2GBプランが3コア(月払いで月額1,738〜1,958円、2026-11時点、税込・リージョンで異なる)で、クレジットカード払いなら2週間の無料お試しがあります。最低利用期間は3ヶ月で、お試し中に解約しないと自動で本登録になる点には注意してください。
② プロセスとスレッドを、同じ画面で見る
言葉で覚える前に、実物を出します。
まずプロセスだけを出します。
UID PID PPID C STIME TTY TIME CMD
root 1 0 0 09:12 ? 00:00:01 /sbin/init
root 387 1 0 09:12 ? 00:00:00 /usr/lib/systemd/systemd-journald
systemd+ 612 1 0 09:12 ? 00:00:00 /usr/lib/systemd/systemd-resolved
root 733 1 0 09:12 ? 00:00:00 /usr/sbin/sshd -D
user 1204 1198 0 09:15 pts/0 00:00:00 -bash
次に、スレッドまで出します。 -L を足すだけです。
UID PID PPID LWP NLWP C STIME TTY TIME CMD
root 1 0 1 1 0 09:12 ? 00:00:01 /sbin/init
root 387 1 387 1 0 09:12 ? 00:00:00 /usr/lib/systemd/systemd-journald
root 421 1 421 1 0 09:12 ? 00:00:00 /usr/lib/systemd/systemd-udevd
systemd+ 612 1 612 4 0 09:12 ? 00:00:00 /usr/lib/systemd/systemd-resolved
systemd+ 612 1 613 4 0 09:12 ? 00:00:00 /usr/lib/systemd/systemd-resolved
systemd+ 612 1 614 4 0 09:12 ? 00:00:00 /usr/lib/systemd/systemd-resolved
systemd+ 612 1 615 4 0 09:12 ? 00:00:00 /usr/lib/systemd/systemd-resolved
ここが全部です。
| 列 | 意味 |
|---|---|
PID | プロセス番号 |
LWP | スレッド番号(Light Weight Process) |
NLWP | そのプロセスが持っているスレッドの数 |
systemd-resolved は PID 612 の行が4回出ています。 プロセスは1つ、スレッドが4つです。 ps -ef では1行でしたが、ps -eLf では4行になります。同じプログラムの中に、4本の実行の流れがあるということです。
Node.js でも確かめます。別のターミナルを開いて、次を走らせておきます。
元のターミナルで数えます。
11
「1行も書いていない Node.js」でも、スレッドは11本あります。 ファイル読み書きや DNS 引きを裏でやるための スレッドプールが最初から立っています。「Node.js はシングルスレッド」は、JavaScript を実行する流れが1本という意味であって、 プロセスの中にスレッドが1本という意味ではありません。
プロセスとスレッド、どこが違うか
根っこは1つだけです。
プロセスはメモリが別。スレッドはメモリを共有する。 他の違いは、全部ここから出てきます。
| プロセス | スレッド | |
|---|---|---|
| メモリ | 完全に別。相手の変数は見えない | 同じものを共有。同じ変数を両方が触れる |
| 作るコスト | 重い。メモリ空間を作り直す | 軽い。空間は借りるだけ |
| 通信の方法 | パイプ・ソケット・共有メモリ。原則コピーが要る | そのまま同じ変数を読む。コピー不要 |
| 1つ落ちたとき | 他は生きる。OSが後片づけする | プロセスごと落ちる。巻き添えになる |
| 壊れ方 | 相手を壊せない | 相手のデータを壊せる(この記事の④) |
| 切り替えコスト | 高い(メモリの地図を差し替える) | 低い(地図はそのまま) |
「安全さを取るならプロセス、速さを取るならスレッド」 という言い方をよくしますが、正確には 「壊れても巻き添えにしたくないならプロセス、大きなデータを渡したくないならスレッド」 です。
- Chrome がタブごとにプロセスを分けているのは、1タブのクラッシュで全部が落ちないため
- 画像処理を worker_threads でやるのは、巨大な画素データをコピーしたくないため
③ 同じ計算を、プロセスとスレッドの両方で並列にする
実測します。 まず「重い計算」を1つ用意します。
// 「重い計算」の中身。素数を数えるだけ。
export function countPrimes(limit) {
let count = 0;
for (let n = 2; n < limit; n++) {
let isPrime = true;
for (let d = 2; d * d <= n; d++) {
if (n % d === 0) { isPrime = false; break; }
}
if (isPrime) count++;
}
return count;
}
直列で測る(基準)
import { countPrimes } from './heavy.mjs';
const LIMIT = 1000000;
const t0 = performance.now();
let total = 0;
for (let i = 0; i < 4; i++) total += countPrimes(LIMIT);
console.log('結果:', total, '所要:', (performance.now() - t0).toFixed(0), 'ms');
結果: 313992 所要: 1639 ms
これが基準です。 1件あたり約 410ms、4件で約 1.6秒。
スレッド(worker_threads)でやる
import { parentPort, workerData } from 'node:worker_threads';
import { countPrimes } from './heavy.mjs';
parentPort.postMessage(countPrimes(workerData.limit));
import { Worker } from 'node:worker_threads';
const LIMIT = 1000000, N = 4;
const t0 = performance.now();
const jobs = [];
for (let i = 0; i < N; i++) {
jobs.push(new Promise((res, rej) => {
const w = new Worker(new URL('./worker-task.mjs', import.meta.url),
{ workerData: { limit: LIMIT } });
w.on('message', res); w.on('error', rej);
}));
}
const parts = await Promise.all(jobs);
console.log('結果:', parts.reduce((a,b)=>a+b,0), '所要:', (performance.now()-t0).toFixed(0), 'ms');
結果: 313992 所要: 609 ms
プロセス(child_process.fork)でやる
import { countPrimes } from './heavy.mjs';
process.on('message', (msg) => {
process.send(countPrimes(msg.limit));
process.exit(0);
});
import { fork } from 'node:child_process';
const LIMIT = 1000000, N = 4;
const t0 = performance.now();
const jobs = [];
for (let i = 0; i < N; i++) {
jobs.push(new Promise((res, rej) => {
const c = fork(new URL('./child-task.mjs', import.meta.url));
c.on('message', res); c.on('error', rej);
c.send({ limit: LIMIT });
}));
}
const parts = await Promise.all(jobs);
console.log('結果:', parts.reduce((a,b)=>a+b,0), '所要:', (performance.now()-t0).toFixed(0), 'ms');
結果: 313992 所要: 631 ms
並べる
| やり方 | 所要 | 直列との比 |
|---|---|---|
| 直列(ただの for) | 1639 ms | 1.0倍 |
| スレッド4本 | 609 ms | 2.7倍 |
| プロセス4個 | 631 ms | 2.6倍 |
4コアで4分割したのに、4倍になりません。2.7倍です。
理由は3つあります。
- ワーカーを4つ立ち上げる時間が丸ごと乗る
- 一番遅い1つが終わるまで全体が終わらない(4つを待ち合わせる)
- VM上では他のプロセスもコアを使っている。4つを丸ごと専有できるわけではない
並列化の効果は、必ず「並列にできない部分」で頭打ちになります。 これをアムダールの法則と言います。半分が並列化できないなら、コアを無限に増やしても2倍が上限です。
起動のコストを、単体で測る
process.send(1);
import { Worker } from 'node:worker_threads';
import { fork } from 'node:child_process';
const N = 20;
// スレッド: 起動して「起きた」と言わせて、終わらせるまで
let t0 = performance.now();
for (let i = 0; i < N; i++) {
await new Promise((res) => {
const w = new Worker('require("worker_threads").parentPort.postMessage(1)', { eval: true });
w.on('message', () => w.terminate().then(res));
});
}
const thread = (performance.now() - t0) / N;
// プロセス: 起動して「起きた」と言わせて、終わらせるまで
t0 = performance.now();
for (let i = 0; i < N; i++) {
await new Promise((res) => {
const c = fork(new URL('./tiny-child.mjs', import.meta.url));
c.on('message', () => { c.kill(); res(); });
});
}
const proc = (performance.now() - t0) / N;
console.log('スレッド1つ作る:', thread.toFixed(1), 'ms');
console.log('プロセス1つ作る:', proc.toFixed(1), 'ms');
console.log('比:', (proc / thread).toFixed(1), '倍');
スレッド1つ作る: 67.2 ms
プロセス1つ作る: 102.5 ms
比: 1.5 倍
どちらも「1つ作るのに 60〜100ms」です。 ここが一番効きます。
10ms で終わる仕事を、100ms かけて作ったワーカーに投げてはいけません。 10倍損をします。 だから実務ではワーカープールを作って使い回すのであって、仕事のたびに作りません。
通信のコストを測る(ここで予想が外れました)
import { parentPort } from 'node:worker_threads';
parentPort.on('message', (m) => parentPort.postMessage(m));
process.on('message', (m) => process.send(m));
import { Worker } from 'node:worker_threads';
import { fork } from 'node:child_process';
const N = 2000;
const small = { n: 1 };
const big = { data: new Array(200000).fill(7) }; // 20万要素
function pingpong(send, on, off, payload, times) {
return new Promise((res) => {
let i = 0;
const t0 = performance.now();
const h = () => {
if (++i >= times) { off(h); res((performance.now() - t0) / times); }
else send(payload);
};
on(h); send(payload);
});
}
const w = new Worker(new URL('./echo-worker.mjs', import.meta.url));
const c = fork(new URL('./echo-child.mjs', import.meta.url));
const ws = await pingpong(m => w.postMessage(m), h => w.on('message', h), h => w.off('message', h), small, N);
const cs = await pingpong(m => c.send(m), h => c.on('message', h), h => c.off('message', h), small, N);
const wb = await pingpong(m => w.postMessage(m), h => w.on('message', h), h => w.off('message', h), big, 50);
const cb = await pingpong(m => c.send(m), h => c.on('message', h), h => c.off('message', h), big, 50);
console.log('小さい値 1往復 スレッド:', ws.toFixed(3), 'ms プロセス:', cs.toFixed(3), 'ms');
console.log('20万要素 1往復 スレッド:', wb.toFixed(1), 'ms プロセス:', cb.toFixed(1), 'ms');
// 共有メモリなら「渡す」こと自体が要らない
const sab = new SharedArrayBuffer(200000 * 4);
const t0 = performance.now();
for (let i = 0; i < 50; i++) w.postMessage({ sab });
console.log('SharedArrayBuffer を50回渡す:', (performance.now() - t0).toFixed(2), 'ms');
await w.terminate(); c.kill();
3回走らせました。
小さい値 1往復 スレッド: 0.698 ms プロセス: 0.184 ms
20万要素 1往復 スレッド: 197.4 ms プロセス: 31.7 ms
SharedArrayBuffer を50回渡す: 0.29 ms
小さい値 1往復 スレッド: 0.393 ms プロセス: 0.169 ms
20万要素 1往復 スレッド: 124.7 ms プロセス: 22.7 ms
SharedArrayBuffer を50回渡す: 0.27 ms
小さい値 1往復 スレッド: 0.060 ms プロセス: 0.093 ms
20万要素 1往復 スレッド: 115.8 ms プロセス: 27.0 ms
SharedArrayBuffer を50回渡す: 0.34 ms
予想が外れました。 私は「スレッドは同じメモリなんだから、渡すのも速いはず」と思っていました。 20万要素の配列は、スレッドのほうが4倍以上遅いという結果です。
理由を調べて、こう理解しました。
postMessageは「渡す」ではなく「複製する」。worker_threadsのpostMessageは構造化複製アルゴリズムでオブジェクトを丸ごと作り直します。child_processのsendは JSON にして送るだけです。 20万要素の配列では、JSON のほうが速いという、それだけの話でした。
そして、本当に効くのは最後の行です。
SharedArrayBufferを50回渡して 0.3ms。 1回あたり 0.006ms。 何もコピーしていないからです。 渡しているのは「同じメモリを見る権利」だけです。
これが「スレッドはメモリを共有する」の実体です。 メッセージを投げているうちは、スレッドの利点はほとんど出ません。 共有メモリを使って初めて桁が変わります。
そして、その瞬間に④の地獄が始まります。
④ 競合状態を、実際に起こす
共有メモリを4つのワーカーで触ります。 それぞれ100万回、1ずつ足します。
合計は 4,000,000 になるはずです。
import { workerData, parentPort } from 'node:worker_threads';
const counter = new Int32Array(workerData.sab);
for (let i = 0; i < workerData.times; i++) {
counter[0] = counter[0] + 1; // 読む → 足す → 書く
}
parentPort.postMessage('done');
import { Worker } from 'node:worker_threads';
const N = 4, TIMES = 1000000;
const sab = new SharedArrayBuffer(4);
const counter = new Int32Array(sab);
counter[0] = 0;
await Promise.all(Array.from({ length: N }, () => new Promise((res, rej) => {
const w = new Worker(new URL('./race-worker.mjs', import.meta.url),
{ workerData: { sab, times: TIMES } });
w.on('message', res); w.on('error', rej);
})));
const expected = N * TIMES;
console.log('期待した数:', expected);
console.log('実際の数 :', counter[0]);
console.log('消えた分 :', expected - counter[0]);
5回走らせます。
期待した数: 4000000
実際の数 : 2896164
消えた分 : 1103836
---
期待した数: 4000000
実際の数 : 2517379
消えた分 : 1482621
---
期待した数: 4000000
実際の数 : 1681105
消えた分 : 2318895
---
期待した数: 4000000
実際の数 : 2763919
消えた分 : 1236081
---
期待した数: 4000000
実際の数 : 4000000
消えた分 : 0
---
この出力の意味を、1行ずつ受け止めてください。
- 毎回違う数字が出ます。 289万、251万、168万、276万
- 400万の半分近くが消えています
- そして5回目は、たまたま正解が出ています
これが「たまにしか再現しないバグ」の正体です。 コードは1文字も変わっていません。 変わったのは、その瞬間にOSがどうスレッドを切り替えたかだけです。
なぜ消えるのか
counter[0] = counter[0] + 1 は、機械から見ると3つの動作です。
1. 読む : メモリから値を取ってくる (例: 100)
2. 足す : レジスタの中で 1 を足す (101)
3. 書く : メモリに書き戻す (100 → 101)
2つのスレッドが、同時にここを通るとこうなります。
| 時刻 | スレッドA | スレッドB | メモリの値 |
|---|---|---|---|
| t1 | 読む → 100 | 100 | |
| t2 | 読む → 100 | 100 | |
| t3 | 足す → 101 | 100 | |
| t4 | 足す → 101 | 100 | |
| t5 | 書く → 101 | 101 | |
| t6 | 書く → 101 | 101 |
2人が1回ずつ足したのに、102ではなく101になりました。1回分が消えました。
Bが読んだ「100」は、書き戻すころには古くなっていたのです。 これを失われた更新(lost update) と言います。 同じSELECTが2回目で変わる — SQL深掘り で扱った データベースの分離レベルの話も、根っこはこれと完全に同じ問題です。
そして、なぜ「たまに正解する」のか。
OSが、たまたま1つのスレッドを最後まで走らせてから次に切り替えたとき、横取りは起きません。 ログを1行足すと再現しなくなるのは、そのログ出力がタイミングをずらすからです。 バグが直ったのではなく、隠れただけです。
直す — Atomics.add
3つの動作を、1つにまとめます。 これを不可分(アトミック)操作と言います。
import { workerData, parentPort } from 'node:worker_threads';
const counter = new Int32Array(workerData.sab);
for (let i = 0; i < workerData.times; i++) {
Atomics.add(counter, 0, 1); // 3段階を1つにまとめる
}
parentPort.postMessage('done');
期待した数: 4000000
実際の数 : 4000000
消えた分 : 0
---
(残り4回も、すべて 4000000 / 消えた分 0)
5回とも 4,000,000 です。
Atomics.add は、CPU の「他の誰にも割り込ませない足し算」命令をそのまま呼んでいます。 「読む→足す→書く」が分割されないので、間に入れません。
正しさには値段がある
import { Worker } from 'node:worker_threads';
const N = 4, TIMES = 1000000;
async function run(file) {
const sab = new SharedArrayBuffer(4);
const counter = new Int32Array(sab);
const t0 = performance.now();
await Promise.all(Array.from({ length: N }, () => new Promise((res, rej) => {
const w = new Worker(new URL(file, import.meta.url), { workerData: { sab, times: TIMES } });
w.on('message', res); w.on('error', rej);
})));
return { ms: performance.now() - t0, value: counter[0] };
}
const a = await run('./race-worker.mjs');
const b = await run('./race-worker-atomic.mjs');
console.log('ふつうの ++ :', a.ms.toFixed(0), 'ms 結果', a.value);
console.log('Atomics.add :', b.ms.toFixed(0), 'ms 結果', b.value);
ふつうの ++ : 129 ms 結果 2133914
Atomics.add : 203 ms 結果 4000000
ふつうの ++ : 104 ms 結果 2606498
Atomics.add : 209 ms 結果 4000000
正しいほうが2倍遅い。
CPU のコアはそれぞれ自分のキャッシュを持っていて、ふだんはそこで済ませています。 不可分操作は「他のコアのキャッシュと足並みを揃えろ」という指示なので、その分だけ必ず遅くなります。
速い間違いより、遅い正解。 ただし 共有する場所を減らせば、その両方が手に入ります。 ワーカーごとに自分のカウンタで数えて、最後に1回だけ合算するなら、不可分操作は4回で済みます。
📸 スクリーンショット2:
for i in 1 2 3 4 5; do node race.mjs; doneの出力。 毎回違う数字が並び、そのうち1回だけ 4000000 が出ているところを残す
⑤ ミューテックスとセマフォを、自分で作る
Atomics.add は足し算しか守れません。もっと大きな処理をまとめて守りたいときは、鍵が要ります。
ミューテックス
Int32Array の1マスを「鍵」にします。 0 = 空いている / 1 = 誰かが持っている。
// ごく小さなミューテックス。Int32Array の1マスを「鍵」に使う。
// 0 = 空いている / 1 = 誰かが持っている
export function lock(l, i = 0) {
for (;;) {
// 「0だったら1にする」を1手でやる。ここが割り込まれない
if (Atomics.compareExchange(l, i, 0, 1) === 0) return;
// 取れなかった。1のあいだ寝て待つ(CPUを回さない)
Atomics.wait(l, i, 1);
}
}
export function unlock(l, i = 0) {
Atomics.store(l, i, 0);
Atomics.notify(l, i, 1); // 寝ている1人を起こす
}
要点は2つです。
| 関数 | やっていること |
|---|---|
Atomics.compareExchange(l, i, 0, 1) | 「今0なら1にする」を1手でやる。2手に分けたら④と同じ壊れ方をする |
Atomics.wait(l, i, 1) | 「まだ1のあいだ、寝る」。CPUを空回りさせない |
Atomics.notify(l, i, 1) | 寝ている1人を起こす |
Atomics.wait はメインスレッドで使いません。 ブラウザのメインスレッドでは例外(TypeError)になります。Node.js のメインスレッドでは呼べてしまいますが、待っている間イベントループが止まります。 どちらも、メインスレッドを止めると画面やイベントループが固まるからです。ワーカーの中でだけ使います。
使ってみます。 ④で壊れた counter[0] = counter[0] + 1 を、そのまま鍵で囲みます。
import { workerData, parentPort } from 'node:worker_threads';
import { lock, unlock } from './mutex.mjs';
const counter = new Int32Array(workerData.counterSab);
const l = new Int32Array(workerData.lockSab);
for (let i = 0; i < workerData.times; i++) {
lock(l);
counter[0] = counter[0] + 1; // 危険な3段階。でも今は自分しか居ない
unlock(l);
}
parentPort.postMessage('done');
import { Worker } from 'node:worker_threads';
const N = 4, TIMES = 100000;
const counterSab = new SharedArrayBuffer(4), lockSab = new SharedArrayBuffer(4);
const counter = new Int32Array(counterSab);
const t0 = performance.now();
await Promise.all(Array.from({ length: N }, () => new Promise((res, rej) => {
const w = new Worker(new URL('./mutex-worker.mjs', import.meta.url),
{ workerData: { counterSab, lockSab, times: TIMES } });
w.on('message', res); w.on('error', rej);
})));
console.log('期待:', N * TIMES, ' 実際:', counter[0], ' 所要:', (performance.now()-t0).toFixed(0), 'ms');
期待: 400000 実際: 400000 所要: 186 ms
期待: 400000 実際: 400000 所要: 176 ms
期待: 400000 実際: 400000 所要: 148 ms
壊れない中身は1行も変えていません。 lock と unlock で囲んだだけです。
ただし、回数を100万から10万に減らしています。 100万回のままだと数秒かかります。 鍵は正しいけれど、確実に遅い。 4本のスレッドが順番待ちの1列になるからです。
ロックで囲んだ範囲(クリティカルセクション)は、並列ではありません。 囲んだ範囲が広いほど、並列化の効果は消えます。 これがアムダールの法則の「並列にできない部分」です。
セマフォ — 人数を決める鍵
ミューテックスは「同時に1人」でした。セマフォは「同時に何人まで」を決めます。
セマフォの人数を1にすると、ミューテックスと同じものになります。 別々の道具ではなく、同じ道具の設定違いです。
// セマフォ = 「同時に入れる人数」を数える鍵。人数1にするとミューテックスと同じ。
export function acquire(s, i = 0) {
for (;;) {
const cur = Atomics.load(s, i);
if (cur > 0 && Atomics.compareExchange(s, i, cur, cur - 1) === cur) return;
Atomics.wait(s, i, cur, 50); // 空くのを待つ(50msで一度起きる)
}
}
export function release(s, i = 0) {
Atomics.add(s, i, 1);
Atomics.notify(s, i, 1);
}
「同時に何人入ったか」を記録しながら使います。
import { workerData, parentPort } from 'node:worker_threads';
import { acquire, release } from './sem.mjs';
const sem = new Int32Array(workerData.semSab);
const stat = new Int32Array(workerData.statSab); // [0]=いま中に居る人数 [1]=最大記録
const sleepBuf = new Int32Array(new SharedArrayBuffer(4));
for (let round = 0; round < 3; round++) {
acquire(sem);
const now = Atomics.add(stat, 0, 1) + 1;
// 最大記録を更新(ここも競合するので compareExchange で回す)
for (;;) {
const max = Atomics.load(stat, 1);
if (now <= max || Atomics.compareExchange(stat, 1, max, now) === max) break;
}
Atomics.wait(sleepBuf, 0, 0, 100); // 100ms の「DBの仕事」
Atomics.sub(stat, 0, 1);
release(sem);
}
parentPort.postMessage('done');
import { Worker } from 'node:worker_threads';
const N = 6, SLOTS = Number(process.argv[2] || 2);
const semSab = new SharedArrayBuffer(4), statSab = new SharedArrayBuffer(8);
const sem = new Int32Array(semSab); sem[0] = SLOTS;
const stat = new Int32Array(statSab);
const t0 = performance.now();
await Promise.all(Array.from({ length: N }, () => new Promise((res, rej) => {
const w = new Worker(new URL('./sem-worker.mjs', import.meta.url),
{ workerData: { semSab, statSab } });
w.on('message', res); w.on('error', rej);
})));
console.log('上限', SLOTS, '人 → 実際に同時に入った最大:', stat[1],
' 全体:', (performance.now()-t0).toFixed(0), 'ms');
上限を変えて3回走らせます。
上限 2 人 → 実際に同時に入った最大: 2 全体: 1174 ms
上限 6 人 → 実際に同時に入った最大: 6 全体: 413 ms
上限 1 人 → 実際に同時に入った最大: 1 全体: 2033 ms
上限を守れています。 そして上限1のとき、これはミューテックスそのものです。
これが実務で何なのか
この形は、そのままDBのコネクションプールです。
- DB が受けられる同時接続が 100 しかないのに、アプリが 1000 本繋ごうとしたらDBが落ちます
- だから「同時に握れるコネクションは20本まで」と上限を決めて、余った人は待たせます
- 待たせるのは正しい。落とすよりはるかにマシです
「同時実行数の上限を決めて、種類ごとに分ける」のをバルクヘッド(隔壁) と言います。 詳しくは 落ちても全部は止めない — サーキットブレーカと縮退 にあります。 セマフォは、その一番小さい実装です。
⑥ デッドロックを起こす — ただし止まらないように
鍵を入れたら安全になった、とはなりません。今度は別の壊れ方をします。
2つのロックを、逆の順番で取ると止まります。
永久に止まると VM を再起動することになるので、必ずタイムアウトを付けます。
// タイムアウト付きのロック。取れなければ false を返す(永久に止まらない)
export function tryLock(l, i, ms) {
const deadline = Date.now() + ms;
for (;;) {
if (Atomics.compareExchange(l, i, 0, 1) === 0) return true;
const left = deadline - Date.now();
if (left <= 0) return false;
Atomics.wait(l, i, 1, left);
}
}
export function unlock(l, i) {
Atomics.store(l, i, 0);
Atomics.notify(l, i, 1);
}
export function sleep(ms) {
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
}
import { workerData, parentPort } from 'node:worker_threads';
import { tryLock, unlock, sleep } from './timed-lock.mjs';
const l = new Int32Array(workerData.lockSab); // [0]=ロックA [1]=ロックB
const [first, second] = workerData.order;
const name = workerData.name;
if (!tryLock(l, first, 2000)) {
parentPort.postMessage(`${name}: 1本目が取れなかった`); process.exit(0);
}
parentPort.postMessage(`${name}: ${'AB'[first]} を取った`);
sleep(200); // ここで相手も1本目を取り終える
if (!tryLock(l, second, 2000)) {
parentPort.postMessage(`${name}: ⚠️ ${'AB'[second]} が2秒待っても取れない(デッドロック)`);
unlock(l, first);
process.exit(0);
}
parentPort.postMessage(`${name}: ${'AB'[second]} も取った → 仕事完了`);
unlock(l, second); unlock(l, first);
import { Worker } from 'node:worker_threads';
const same = process.argv[2] === 'same';
const lockSab = new SharedArrayBuffer(8);
const plans = [
{ name: 'ワーカー1', order: [0, 1] },
{ name: 'ワーカー2', order: same ? [0, 1] : [1, 0] },
];
console.log(same ? '=== 直したあと: 2人とも A → B の順で取る ==='
: '=== わざと壊す: 1は A→B、2は B→A ===');
await Promise.all(plans.map(p => new Promise((res, rej) => {
const w = new Worker(new URL('./deadlock-worker.mjs', import.meta.url),
{ workerData: { lockSab, ...p } });
w.on('message', m => console.log(m));
w.on('exit', res); w.on('error', rej);
})));
壊します。
=== わざと壊す: 1は A→B、2は B→A ===
ワーカー1: A を取った
ワーカー2: B を取った
ワーカー1: ⚠️ B が2秒待っても取れない(デッドロック)
ワーカー2: A も取った → 仕事完了
読み方です。
- ワーカー1が A を持ち、ワーカー2が B を持った時点で輪ができました
- 1は B を待ち、2は A を待つ。どちらも相手が離すまで進めません
- 2秒のタイムアウトで、ワーカー1が諦めて A を離しました
- その瞬間にワーカー2が A を取れて、完走しました
タイムアウトが無ければ、この2つは永久に止まっています。 「サーバーが固まった。CPUは0%。ログも出ない」の典型がこれです。
直します。順番を揃えるだけです。
=== 直したあと: 2人とも A → B の順で取る ===
ワーカー1: A を取った
ワーカー1: B も取った → 仕事完了
ワーカー2: A を取った
ワーカー2: B も取った → 仕事完了
コードの中身は同じです。取る順番を1つに決めただけです。
デッドロックの4条件
デッドロックは、次の4つが同時に成り立ったときだけ起きます。
| 条件 | 意味 | 崩すとどうなるか |
|---|---|---|
| 相互排除 | その資源は同時に1人しか使えない | 崩せないことが多い(DBの行ロックなど) |
| 保持と待機 | 持ったまま、次を待つ | 必要な鍵を全部まとめて取る(取れなければ全部離す) |
| 横取り不可 | 他人から取り上げられない | タイムアウトを付ける(上でやったのがこれ) |
| 循環待ち | 待ちの輪ができる | ロックに順番を付ける(上の same がこれ) |
1つ崩せば止まりません。 実務で一番効くのは「循環待ち」を崩す、つまりロックを取る順番をコード全体で1つに決めることです。 「テーブルは必ず ID の小さい順にロックする」のようなルールを、チームで1つ決めます。
MySQL や PostgreSQL は、デッドロックを検出したら片方を強制終了します。 Deadlock found when trying to get lock というエラーを見たことがあれば、あれが「輪を切った」通知です。 アプリ側はそのトランザクションを丸ごとやり直すのが正解です。
⑦ スケジューリング — CPUは1つずつしか実行していない
1つのコアは、同時に1つの命令しか実行できません。 top に50個のプロセスが並んでいても、4コアならその瞬間に走っているのは4つだけです。
残りは止まっています。 速く見えるのは、OSが高速で切り替えているからです。
切り替えを数える
vmstat の cs 列がコンテキストスイッチの回数(毎秒) です。
まず、何もしていない状態を測ります。
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
0 0 0 2814216 75440 612884 0 0 8 3 61 102 0 0 99 0 0
0 0 0 2814216 75440 612884 0 0 0 0 48 88 0 0 100 0 0
0 0 0 2814216 75440 612884 0 0 0 0 52 95 0 0 100 0 0
cs は 100 前後。id(idle)が 100 で、何もしていません。
次に、CPUを使うプロセスを4つ立てます。
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
4 0 0 2701104 75440 612900 0 0 0 0 318 412 98 2 0 0 0
4 0 0 2701104 75440 612900 0 0 0 0 302 388 99 1 0 0 0
4 0 0 2701104 75440 612900 0 0 0 0 311 401 99 1 0 0 0
r が 4 になりました。 これは「走る準備ができて待っている数」 です。us(ユーザー時間)が 98〜99%。
さらに増やして、16個にします。
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
16 0 0 2402880 75444 612912 0 0 0 0 892 1746 97 3 0 0 0
15 0 0 2402880 75444 612912 0 0 0 0 874 1702 98 2 0 0 0
16 0 0 2402880 75444 612912 0 0 0 0 901 1783 97 3 0 0 0
cs が 400 前後から 1700 前後に増えました。
| プロセス数 | r(待ち行列) | cs(毎秒の切り替え) |
|---|---|---|
| 0 | 0 | 約 90 |
| 4 | 4 | 約 390 |
| 16 | 16 | 約 1700 |
プロセスを増やしても、終わる仕事の量は増えません。CPUは4つのままです。 増えるのは「切り替えの回数」だけ。 そして切り替えにもCPUを使います。
これが「並列度を上げたのに遅くなった」の正体です。 ワーカーの数は、コア数を超えて増やす意味がほとんどありません。
終わるまで待つか、止めます。
止めました
kill の使い分けは kill -9 を最初に打たない — Linux深掘り にあります。
スケジューリング方式
「次にどれを走らせるか」の決め方には、いくつかの型があります。
| 方式 | 決め方 | 長所 | 短所 |
|---|---|---|---|
| 先着順(FCFS) | 来た順 | 単純。飢餓が起きない | 長いのが先頭に来ると全部待つ(護送船団効果) |
| 短いものから(SJF) | 予想実行時間が短い順 | 平均待ち時間が理論上最小 | 長いものが永久に待つ(飢餓)。実行時間は事前に分からない |
| ラウンドロビン | 一定時間ずつ順番に回す | 公平。応答が均等 | 時間を短くすると切り替えコストが増える |
| 優先度つき | 優先度の高い順 | 大事な仕事を先に | 低優先度が飢える(対策: 待つほど優先度を上げる) |
Linux の既定は長く CFS(完全公平スケジューラ)で、6.6 以降はその後継の EEVDF で、大まかには 「これまでCPUを使えていない人ほど先に回す」 という考え方です。 ラウンドロビンと優先度を混ぜたものだと思っておけば、最初は足ります。
優先度を実際に下げる
nice 値は -20(最優先)〜 19(最も譲る)。既定は 0 です。 下げる(数字を大きくする)のは誰でもできますが、上げるには root が要ります。
同じ仕事を2つ、優先度を変えて走らせます。
top - 09:41:02 up 29 min, 1 user, load average: 1.42, 0.68, 0.31
%Cpu(s): 51.2 us, 0.6 sy, 0.0 ni, 48.0 id, 0.0 wa, 0.0 hi, 0.2 si, 0.0 st
PID USER PR NI %CPU %MEM TIME+ COMMAND
2841 user 20 0 99.3 1.4 0:11.02 node
2843 user 39 19 98.7 1.4 0:10.88 node
2846 user 20 0 0.7 0.1 0:00.02 top
両方 99% です。差が出ていません。
当然でした。コアが4つあるので、2つとも別のコアで走れます。取り合いが起きていません。
取り合いを起こすには、コア数より多く走らせる必要があります。 6つに増やします。
top - 09:43:18 up 31 min, 1 user, load average: 4.81, 2.11, 0.94
Tasks: 137 total, 7 running, 130 sleeping, 0 stopped, 0 zombie
%Cpu(s): 96.8 us, 2.1 sy, 1.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.1 si, 0.0 st
PID USER PR NI %CPU %MEM TIME+ COMMAND
2902 user 20 0 79.4 1.4 0:03.98 node
2904 user 20 0 79.1 1.4 0:03.96 node
2906 user 20 0 78.8 1.4 0:03.94 node
2908 user 20 0 78.6 1.4 0:03.93 node
2910 user 20 0 78.4 1.4 0:03.92 node
2913 user 39 19 5.2 1.4 0:00.26 node
今度ははっきり出ました。
- 通常の5つは 約 78% ずつ
NI 19の1つだけ 5.2%TIME+(累積CPU時間)も 3.98秒 対 0.26秒 で、15倍の差
走行中に優先度を変えることもできます。 renice です。
2902 (process ID) old priority 0, new priority 19
確認します。
PID USER PR NI %CPU %MEM TIME+ COMMAND
2904 user 20 0 97.6 1.4 0:09.12 node
2906 user 20 0 97.4 1.4 0:09.10 node
2908 user 20 0 97.1 1.4 0:09.08 node
2910 user 20 0 96.9 1.4 0:09.06 node
2902 user 39 19 4.9 1.4 0:04.21 node
2902 は %CPU が 79% から 4.9% に落ちました。 残り4つは 97% に上がっています。
バックアップやログ圧縮のような「遅くていい仕事」には nice -n 19 を付けます。 止めるのではなく、譲らせるのがポイントです。仕事は進みますが、他の邪魔をしません。
止めました
📸 スクリーンショット3:
nice -n 19を付けたプロセスだけ%CPUが一桁になっているtopの出力。NI列と%CPU列が並んで見えるところを残す
⑧ メモリ管理 — 全員が「メモリは全部自分のもの」と思っている
仮想メモリ
各プロセスは、「メモリの先頭から末尾まで、全部自分が持っている」と思い込んでいます。
これは嘘です。 OS と CPU がアドレスの読み替えをやっています。
プロセスAが見ているアドレス 0x1000 → 実メモリの 0x7A3F000
プロセスBが見ているアドレス 0x1000 → 実メモリの 0x2C11000
同じ「0x1000」でも、指している実メモリは別です。 だから プロセスAは、どうやってもプロセスBのメモリを読めません。 これが「プロセスは安全」の中身です。
読み替えはページという固定サイズ(普通4KB)の単位でやります。これがページングです。
4096
この仕組みのおかげでできること。
| できること | 中身 |
|---|---|
| プロセスの隔離 | 他人のメモリに触れない |
| 実メモリより大きく見せる | 使っていないページはディスクへ追い出す(スワップ) |
| 同じものを二重に持たない | libc などの共有ライブラリは実メモリ上に1つ。全プロセスが同じページを見る |
| 確保しても使うまで載らない | malloc した瞬間には実メモリを使わない(遅延割り当て) |
free -h を読む
total used free shared buff/cache available
Mem: 3.8Gi 684Mi 2.5Gi 1.0Mi 598Mi 2.9Gi
Swap: 2.0Gi 0B 2.0Gi
free の列を見て「空きが2.5Giしかない」と焦らないでください。
| 列 | 意味 |
|---|---|
used | プロセスが実際に使っている |
free | 完全に手つかず。少なくても問題ない |
buff/cache | ディスクの内容をメモリに置いているだけ。必要になれば即座に空く |
available | 本当に見るべき列。 「新しいプロセスに渡せる量」 |
freeが少ないのは正常です。 Linux は空きメモリを遊ばせずキャッシュに使います。 見るのはavailableだけでいい。
ps の RSS を全部足すと、実メモリを超える
実演します。
RSSの合計: 1284.73 MiB
実メモリ : 3907 MiB (うち used 684 MiB)
RSS の合計 1284 MiB に対して、実際の used は 684 MiB。約2倍ずれています。
理由です。
RSS(Resident Set Size)は「そのプロセスが実メモリ上に持っているページの量」です。 共有ライブラリのページは、全プロセスの RSS にそれぞれ数えられます。 libc が 2MB で、それを 50 個のプロセスが使っていたら、RSS の合計には 100MB 出ますが、 実メモリ上には 2MB しかありません。
共有分を除いた量を見たいときは PSS(Proportional Set Size)を使います。 共有分を人数で割った値です。
PSSの合計: 701.16 MiB
701 MiB。free の used(684 MiB)とほぼ一致しました。
「メモリを一番食っているのは誰か」を RSS で探すのは、目安としては使えます。 でも「全部足したら何MB」を RSS でやると必ず間違えます。
/proc/meminfo
free はここを読んで整形しているだけです。
MemTotal: 4001200 kB
MemFree: 2611584 kB
MemAvailable: 3056640 kB
Buffers: 77256 kB
Cached: 535944 kB
SwapCached: 0 kB
Active(anon): 481324 kB
Inactive(file): 479088 kB
| 行 | 意味 |
|---|---|
MemAvailable | これが「渡せる量」。free -h の available はこれ |
Active(anon) | ファイルに由来しない、プロセスが確保したメモリ |
Inactive(file) | しばらく触っていないファイルキャッシュ。真っ先に捨てられる |
スワップが始まると、桁で遅くなる
メモリが足りなくなると、OS は使っていないページをディスクへ追い出します。 これがスワップです。
MemAvailable: 3056640 kB
SwapTotal: 2097148 kB
SwapFree: 2097148 kB
60
メモリとディスクの速度差は、だいたい1000倍以上です。
| 場所 | だいたいの読み出し時間 |
|---|---|
| CPUキャッシュ | 1ナノ秒 前後 |
| メインメモリ | 100ナノ秒 前後 |
| SSD | 100マイクロ秒 前後(メモリの約1000倍) |
| ハードディスク | 10ミリ秒 前後(メモリの約10万倍) |
「サーバーが急に何をしても遅くなった」の代表がスワップです。
vmstatのsi/so(swap in / swap out)が0以外になり続けていたら、それです。 CPU使用率は低いのに遅い、という形で出ます。 CPUは待っているだけだからです。
確認のしかたです。
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
0 0 0 2611584 77256 535944 0 0 8 3 61 102 0 0 99 0 0
0 0 0 2611584 77256 535944 0 0 0 0 49 90 0 0 100 0 0
0 0 0 2611584 77256 535944 0 0 0 0 51 93 0 0 100 0 0
si も so も 0。健康です。
OOM Killer
スワップも尽きたら、OS は「誰かを殺して助かる」ほうを選びます。 これが OOM Killer です。
(何も出ない)
出なければ、このVMではまだ発動していません。 発動していると、こういう行が出ます。
[12345.678901] Out of memory: Killed process 4821 (node) total-vm:2841044kB, anon-rss:1892344kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:4092kB oom_score_adj:0
これが「アプリのログに何も残っていないのに、プロセスだけ消えている」の正体です。 アプリは自分が殺されたことを知りません。
sudo journalctl -k | grep -i "killed process" でも同じものが見えます。
Docker のコンテナが exit code 137 で落ちていたら、まずこれを疑います。 137 = 128 + 9、つまり SIGKILL です。コンテナのメモリ上限に当たったということです。 コンテナのメモリ制限の仕組みは コンテナの正体は名前空間とcgroups — Linux深掘り にあります。
判断表 — プロセスか、スレッドか、非同期か
最後に、実際に選ぶときの表です。
まず、非同期で足りるかを確かめます。 測りました。
import { countPrimes } from './heavy.mjs';
const wait = (ms) => new Promise(r => setTimeout(r, ms));
// ① 待つだけの仕事 200件(DBやAPIの返事を待つのと同じ形)
let t0 = performance.now();
await Promise.all(Array.from({ length: 200 }, () => wait(50)));
console.log('待つ仕事200件を非同期で:', (performance.now() - t0).toFixed(0), 'ms');
// ② CPUを使う仕事を「非同期っぽく」書いても、1スレッドなら足し算のまま
t0 = performance.now();
await Promise.all(Array.from({ length: 4 }, async () => countPrimes(1000000)));
console.log('CPUの仕事4件を非同期で :', (performance.now() - t0).toFixed(0), 'ms');
// ③ 比較: ただの for ループ(非同期を使わない)
t0 = performance.now();
for (let i = 0; i < 4; i++) countPrimes(1000000);
console.log('CPUの仕事4件を直列で :', (performance.now() - t0).toFixed(0), 'ms');
待つ仕事200件を非同期で: 66 ms
CPUの仕事4件を非同期で : 1692 ms
CPUの仕事4件を直列で : 1641 ms
この3行が全部です。
- 50ms 待つ仕事を200件、66ms で終わりました。 直列なら10秒です。待つ仕事に並列は要りません
- CPUを使う仕事は、
asyncを付けても 1692ms。for ループの 1641ms とほぼ同じ asyncは「速くする道具」ではありません。「待っている間に別のことをする道具」です
| 仕事の性質 | 選ぶもの | 理由 |
|---|---|---|
| DB・API・ファイルの返事を待つ | 非同期(1スレッドのまま) | 待っている間 CPU は空いている。ワーカーは要らない |
| 画像変換・圧縮・暗号化・大量計算 | worker_threads | CPUを本当に使う。数はコア数まで |
| 落ちても他を巻き込みたくない | child_process / 別プロセス | メモリが別なので、巻き添えにならない |
| 信用できないコードを走らせる | 別プロセス(+コンテナ) | スレッドでは隔離できない |
| CPUコアを全部使ってHTTPを捌く | cluster モジュール | プロセスを複数立てて1つのポートを共有する |
| 大きなバイナリを何度も渡す | worker_threads + SharedArrayBuffer | コピーが消える。ただし④のバグと同居する |
Node.js では、まず非同期で足ります。 ワーカーを入れるのは、「プロファイルを取って、CPUで詰まっていることを確かめてから」です。 非同期そのものの話は fetchの結果が undefined — 非同期処理の基本 にあります。
つまずいたところ
1. ログを足したら再現しなくなり、「直った」と思った
直っていません。隠れただけです。 console.log は I/O なので、そこで実行が数マイクロ秒止まります。 その分だけ横取りの窓が閉じます。 本番で負荷が上がった瞬間に、また出ます。
2. Atomics.wait をメインスレッドで呼ぶと、ブラウザでは例外になる
TypeError: Atomics.wait cannot be called in this context
上はブラウザ(Chrome など)のメインスレッドで出るエラーです(文言はブラウザや版によって異なる場合があります)。 Node.js のメインスレッドでは例外にならず呼べてしまいます(Node.js v22.14.0 で確認)。ただし待っている間はイベントループが止まり、タイマーも I/O も進みません。どちらでも、Atomics.wait はワーカーの中でだけ使います。 メインスレッドで待ちたいときは Atomics.waitAsync を使います(Promise を返します)。
3. スレッドのほうが通信が速いと思い込んでいた
③で測って外れました。postMessage は「渡す」ではなく「複製する」。 SharedArrayBuffer を使わない限り、スレッドでもコピーは起きます。 共有メモリを使わない worker_threads は、通信面では別プロセスと変わりません。
4. ワーカーを増やせば増やすほど速くなると思っていた
⑦で cs が4倍以上に増えました。コア数を超えたら、増えるのは切り替えの回数だけです。 os.availableParallelism() を使って、コア数に合わせて決めるのが安全です。
5. nice を付けたのに差が出なかった
コアが余っていたら、優先度は関係ありません。 取り合いが起きていないからです。 優先度が効くのは「足りないとき」だけ。 実験するときはコア数より多く走らせる必要があります。
6. デッドロックの実験で、危うくVMを固めるところだった
最初はタイムアウト無しで書きました。2つのワーカーが永久に止まりました。 Ctrl+C は効きましたが、実験用のロックには最初からタイムアウトを付けてください。 本番のコードでも同じです。「取れなかったら諦める」を最初から書きます。
7. ps の RSS を足して「メモリが足りない」と報告しかけた
RSS の合計は実メモリを超えます。 共有ライブラリを人数分数えているからです。 見るのは free -h の available、プロセス別に正確に見たいなら PSS です。
8. free の free が少ないのを見て、メモリ不足だと思った
buff/cache はいつでも空けられます。 Linux は空きメモリをキャッシュに回すのが正常な動作です。 available を見てください。 そこが小さいときだけ、本当に足りていません。
後片づけ
まず、走りっぱなしのプロセスが無いか確認します。
(何も出なければOK)
残っていたら止めます。
終了コード: 1
1 は「該当なし」です。 何も残っていなかったということなので、正常です。
作業フォルダを消します。
(空、または他の記事のフォルダ)
rm -rf は戻せません。 パスを打つ前に ls ~/cslab/proc で中身を確認してください。
VMのコア数を戻したい人は、VMware の設定を元に戻してください(この記事以外では2コアで十分です)。
まとめ — 理解できたこと
- プロセスとスレッドの違いは「メモリを分けるか共有するか」の1点。作るコスト・通信・巻き添えは全部そこから出る
ps -eLfのNLWP列でスレッド数が見える。 何も書いていない Node.js でもスレッドは11本ある- 4コアで4分割しても4倍にならない。実測で 2.7倍。起動と待ち合わせの分が必ず引かれる(アムダールの法則)
- ワーカーの起動は 60〜100ms。 10ms の仕事に作ってはいけない。プールで使い回す
postMessageは複製する。 20万要素なら構造化複製より JSON のほうが速かった。共有の利点はSharedArrayBufferで初めて出るx = x + 1は「読む→足す→書く」の3動作。途中で横取りされると1回分が消える- 競合状態は毎回違う数を出し、たまに正解する。 5回中1回、400万ちょうどが出た。これが「たまに再現しないバグ」
Atomics.addにすると必ず正しい。ただし2倍遅い。 正しさにはキャッシュ同期という値段がある- ミューテックスは
compareExchange+wait/notifyで30行で書ける。 中身は「0なら1にする」だけ - セマフォは人数を決める鍵。人数1がミューテックス。 DBコネクション上限とバルクヘッドはこの形
- ロックを逆順に取るとデッドロック。 直し方は取る順番を全体で1つに決める。4条件のうち1つ崩せばよい
- CPUは1コアで1つしか実行していない。 プロセスを16に増やすと
csが1700に跳ね、仕事量は増えない niceはコアが余っていると効かない。 足りないときだけ、%CPUが79%から5%に落ちたpsの RSS 合計は実メモリを超える(共有分の二重計上)。見るのはfreeのavailableとPSS- メモリとディスクは1000倍以上違う。 スワップが始まると「CPUは低いのに遅い」形で出る
exit code 137は OOM Killer。 アプリのログには何も残らない。dmesg | grep -i oomで探す- Node.js ではまず非同期で足りる。 待つ仕事200件が66ms。ワーカーはCPUで詰まっていることを測ってから
参考リンク
- Node.js 公式: Worker threads
- Node.js 公式: Child process
- Node.js 公式: Cluster
- MDN: Atomics
- MDN: SharedArrayBuffer
- man7.org: pthreads(7) — スレッドとプロセスの関係
- man7.org: sched(7) — Linux のスケジューリング方式
- man7.org: proc(5) — /proc/meminfo などの各項目
- kernel.org: Documentation — CFS スケジューラの設計
- kernel.org: Documentation — メモリ管理の概要
- roadmap.sh: Computer Science
次に読む
この記事は 【深掘り】コンピュータ科学 の 18 / 25 本目です。
| 記事 | |
|---|---|
| ← 前の記事 | PとNP・NP完全 — 答え合わせは一瞬なのに解けない |
| → 次の記事 | デザインパターンとDI — テストが書けないのは設計のせい |
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
- 競合状態を実際に起こす
- ロック・スケジューリング・仮想メモリ
この記事は、上の項目を実際に手を動かして確かめる回です。

コメント