プロセスとスレッドと競合状態 — たまにだけ数が合わない

プロセスとスレッド。複数の作業装置と共有するカウンターの箱、排他制御を表す鍵。

※本記事はアフィリエイト広告(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を使う仕事だけ

この記事でやること

  1. VMのコア数を確認し、足りなければ増やす
  2. ps -eLf で、プロセスとスレッドの両方を1画面に出して違いを見る
  3. child_process.fork と worker_threads で同じ計算を並列にし、起動と通信のコストを実測する
  4. SharedArrayBuffer で競合状態をわざと起こし、Atomics.add で直す
  5. Atomics.wait / Atomics.notify でミューテックスとセマフォを自作する
  6. ロックの順番を逆にしてデッドロックを起こし、タイムアウトで安全に抜ける
  7. vmstat / nice / top でスケジューリングを目で見る
  8. free -h / /proc/meminfo / dmesg で仮想メモリの読み方を確かめる

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
プロセス実行中のプログラム1つ。自分専用のメモリ空間を持つ
スレッドプロセスの中の実行の流れ。同じプロセスのスレッドはメモリを共有する
競合状態(レースコンディション)複数の実行の流れが同じ場所を同時に触って、順番次第で結果が変わること
不可分(アトミック)途中で割り込まれないこと。「読む→足す→書く」を1手でやる
ミューテックス「同時に1人だけ」を保証する鍵。mutual exclusion(相互排除) の略
セマフォ同時に入れる人数を決める鍵。人数を1にするとミューテックス
デッドロックお互いが相手の持っている鍵を待って、永久に動かなくなること
コンテキストスイッチCPUが実行するものを切り替えること。切り替え自体にも時間がかかる
仮想メモリ各プロセスが「メモリを全部自分が持っている」と思い込める仕組み
ページングメモリを固定サイズ(通常4KB)のページに区切って管理すること

① 環境を確認する — コアが1つだと実験にならない

まず VM のコア数を見ます。

bash
$ nproc
4

ここが 1 だった人は、先に VM の設定を変えてください。 VMware Workstation の「仮想マシン設定 → プロセッサ」で、「プロセッサコアの総数」を 2 以上にします (VMを一度シャットダウンしてから変更します)。1コアのままだと、この記事の③④⑦は差が出ません。

もう少し詳しく見ます。

bash
$ lscpu | head -20
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): 4OSから見える実行単位が4つ。同時に4つまで本当に走る
On-line CPU(s) list: 0-3番号は0から。taskset などで指定するときに使う
Thread(s) per core: 11コアあたりのハードウェアスレッド数。2ならハイパースレッディング有効

「CPU(s): 4」は「4つ同時に走る」ということであって、「4倍速くなる」ではありません。 そこは③で測ります。

Node.js が入っているかも確認します。

bash
$ node -v
v22.14.0

node が無ければ sudo apt install -y nodejs npm で入れてから進めてください。

作業場所を作ります。最後に消します。

bash
$ mkdir -p ~/cslab/proc
$ cd ~/cslab/proc
$ pwd
/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ヶ月で、お試し中に解約しないと自動で本登録になる点には注意してください。

② プロセスとスレッドを、同じ画面で見る

言葉で覚える前に、実物を出します。

まずプロセスだけを出します。

bash
$ ps -ef | head -8
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 を足すだけです。

bash
$ ps -eLf | head -8
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 でも確かめます。別のターミナルを開いて、次を走らせておきます。

bash
$ node -e "setTimeout(()=>{}, 60000)"

元のターミナルで数えます。

bash
$ ps -eLf | grep -c "[n]ode"
11

「1行も書いていない Node.js」でも、スレッドは11本あります。 ファイル読み書きや DNS 引きを裏でやるための スレッドプールが最初から立っています。「Node.js はシングルスレッド」は、JavaScript を実行する流れが1本という意味であって、 プロセスの中にスレッドが1本という意味ではありません。

プロセスとスレッド、どこが違うか

根っこは1つだけです。

プロセスはメモリが別。スレッドはメモリを共有する。 他の違いは、全部ここから出てきます。

プロセススレッド
メモリ完全に別。相手の変数は見えない同じものを共有。同じ変数を両方が触れる
作るコスト重い。メモリ空間を作り直す軽い。空間は借りるだけ
通信の方法パイプ・ソケット・共有メモリ。原則コピーが要るそのまま同じ変数を読む。コピー不要
1つ落ちたとき他は生きる。OSが後片づけするプロセスごと落ちる。巻き添えになる
壊れ方相手を壊せない相手のデータを壊せる(この記事の④)
切り替えコスト高い(メモリの地図を差し替える)低い(地図はそのまま)

「安全さを取るならプロセス、速さを取るならスレッド」 という言い方をよくしますが、正確には 「壊れても巻き添えにしたくないならプロセス、大きなデータを渡したくないならスレッド」 です。

  • Chrome がタブごとにプロセスを分けているのは、1タブのクラッシュで全部が落ちないため
  • 画像処理を worker_threads でやるのは、巨大な画素データをコピーしたくないため

③ 同じ計算を、プロセスとスレッドの両方で並列にする

実測します。 まず「重い計算」を1つ用意します。

bash
$ nano heavy.mjs
// 「重い計算」の中身。素数を数えるだけ。
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;
}

直列で測る(基準)

bash
$ nano serial.mjs
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');
bash
$ node serial.mjs
結果: 313992 所要: 1639 ms

これが基準です。 1件あたり約 410ms、4件で約 1.6秒。

スレッド(worker_threads)でやる

bash
$ nano worker-task.mjs
import { parentPort, workerData } from 'node:worker_threads';
import { countPrimes } from './heavy.mjs';
parentPort.postMessage(countPrimes(workerData.limit));
bash
$ nano par-thread.mjs
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');
bash
$ node par-thread.mjs
結果: 313992 所要: 609 ms

プロセス(child_process.fork)でやる

bash
$ nano child-task.mjs
import { countPrimes } from './heavy.mjs';
process.on('message', (msg) => {
  process.send(countPrimes(msg.limit));
  process.exit(0);
});
bash
$ nano par-process.mjs
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');
bash
$ node par-process.mjs
結果: 313992 所要: 631 ms

並べる

やり方所要直列との比
直列(ただの for)1639 ms1.0倍
スレッド4本609 ms2.7倍
プロセス4個631 ms2.6倍

4コアで4分割したのに、4倍になりません。2.7倍です。

理由は3つあります。

  1. ワーカーを4つ立ち上げる時間が丸ごと乗る
  2. 一番遅い1つが終わるまで全体が終わらない(4つを待ち合わせる)
  3. VM上では他のプロセスもコアを使っている。4つを丸ごと専有できるわけではない

並列化の効果は、必ず「並列にできない部分」で頭打ちになります。 これをアムダールの法則と言います。半分が並列化できないなら、コアを無限に増やしても2倍が上限です。

起動のコストを、単体で測る

bash
$ nano tiny-child.mjs
process.send(1);
bash
$ nano spawn-cost.mjs
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), '倍');
bash
$ node spawn-cost.mjs
スレッド1つ作る: 67.2 ms
プロセス1つ作る: 102.5 ms
比: 1.5 倍

どちらも「1つ作るのに 60〜100ms」です。 ここが一番効きます。

10ms で終わる仕事を、100ms かけて作ったワーカーに投げてはいけません。 10倍損をします。 だから実務ではワーカープールを作って使い回すのであって、仕事のたびに作りません。

通信のコストを測る(ここで予想が外れました)

bash
$ nano echo-worker.mjs
import { parentPort } from 'node:worker_threads';
parentPort.on('message', (m) => parentPort.postMessage(m));
bash
$ nano echo-child.mjs
process.on('message', (m) => process.send(m));
bash
$ nano msg-cost.mjs
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回走らせました。

bash
$ node msg-cost.mjs; node msg-cost.mjs; node msg-cost.mjs
小さい値 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 になるはずです。

bash
$ nano race-worker.mjs
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');
bash
$ nano race.mjs
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回走らせます。

bash
$ for i in 1 2 3 4 5; do node race.mjs; echo ---; done
期待した数: 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読む → 100100
t2読む → 100100
t3足す → 101100
t4足す → 101100
t5書く → 101101
t6書く → 101101

2人が1回ずつ足したのに、102ではなく101になりました。1回分が消えました。

Bが読んだ「100」は、書き戻すころには古くなっていたのです。 これを失われた更新(lost update) と言います。 同じSELECTが2回目で変わる — SQL深掘り で扱った データベースの分離レベルの話も、根っこはこれと完全に同じ問題です。

そして、なぜ「たまに正解する」のか。

OSが、たまたま1つのスレッドを最後まで走らせてから次に切り替えたとき、横取りは起きません。 ログを1行足すと再現しなくなるのは、そのログ出力がタイミングをずらすからです。 バグが直ったのではなく、隠れただけです。

直す — Atomics.add

3つの動作を、1つにまとめます。 これを不可分(アトミック)操作と言います。

bash
$ nano race-worker-atomic.mjs
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');
bash
$ sed 's|race-worker.mjs|race-worker-atomic.mjs|' race.mjs > race-atomic.mjs
$ for i in 1 2 3 4 5; do node race-atomic.mjs; echo ---; done
期待した数: 4000000
実際の数  : 4000000
消えた分  : 0
---
(残り4回も、すべて 4000000 / 消えた分 0)

5回とも 4,000,000 です。

Atomics.add は、CPU の「他の誰にも割り込ませない足し算」命令をそのまま呼んでいます。 「読む→足す→書く」が分割されないので、間に入れません。

正しさには値段がある

bash
$ nano race-time.mjs
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);
bash
$ node race-time.mjs; node race-time.mjs
ふつうの ++     : 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 = 誰かが持っている。

bash
$ nano mutex.mjs
// ごく小さなミューテックス。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 を、そのまま鍵で囲みます。

bash
$ nano mutex-worker.mjs
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');
bash
$ nano mutex-run.mjs
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');
bash
$ for i in 1 2 3; do node mutex-run.mjs; done
期待: 400000  実際: 400000  所要: 186 ms
期待: 400000  実際: 400000  所要: 176 ms
期待: 400000  実際: 400000  所要: 148 ms

壊れない中身は1行も変えていません。 lock と unlock で囲んだだけです。

ただし、回数を100万から10万に減らしています。 100万回のままだと数秒かかります。 鍵は正しいけれど、確実に遅い。 4本のスレッドが順番待ちの1列になるからです。

ロックで囲んだ範囲(クリティカルセクション)は、並列ではありません。 囲んだ範囲が広いほど、並列化の効果は消えます。 これがアムダールの法則の「並列にできない部分」です。

セマフォ — 人数を決める鍵

ミューテックスは「同時に1人」でした。セマフォは「同時に何人まで」を決めます。

セマフォの人数を1にすると、ミューテックスと同じものになります。 別々の道具ではなく、同じ道具の設定違いです。

bash
$ nano sem.mjs
// セマフォ = 「同時に入れる人数」を数える鍵。人数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);
}

「同時に何人入ったか」を記録しながら使います。

bash
$ nano sem-worker.mjs
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');
bash
$ nano sem-run.mjs
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回走らせます。

bash
$ node sem-run.mjs 2; node sem-run.mjs 6; node sem-run.mjs 1
上限 2 人  → 実際に同時に入った最大: 2  全体: 1174 ms
上限 6 人  → 実際に同時に入った最大: 6  全体: 413 ms
上限 1 人  → 実際に同時に入った最大: 1  全体: 2033 ms

上限を守れています。 そして上限1のとき、これはミューテックスそのものです。

これが実務で何なのか

この形は、そのままDBのコネクションプールです。

  • DB が受けられる同時接続が 100 しかないのに、アプリが 1000 本繋ごうとしたらDBが落ちます
  • だから「同時に握れるコネクションは20本まで」と上限を決めて、余った人は待たせます
  • 待たせるのは正しい。落とすよりはるかにマシです

「同時実行数の上限を決めて、種類ごとに分ける」のをバルクヘッド(隔壁) と言います。 詳しくは 落ちても全部は止めない — サーキットブレーカと縮退 にあります。 セマフォは、その一番小さい実装です。


⑥ デッドロックを起こす — ただし止まらないように

鍵を入れたら安全になった、とはなりません。今度は別の壊れ方をします。

2つのロックを、逆の順番で取ると止まります。

永久に止まると VM を再起動することになるので、必ずタイムアウトを付けます。

bash
$ nano timed-lock.mjs
// タイムアウト付きのロック。取れなければ 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);
}
bash
$ nano deadlock-worker.mjs
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);
bash
$ nano deadlock-run.mjs
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);
})));

壊します。

bash
$ node deadlock-run.mjs
=== わざと壊す: 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%。ログも出ない」の典型がこれです。

直します。順番を揃えるだけです。

bash
$ node deadlock-run.mjs same
=== 直したあと: 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 列がコンテキストスイッチの回数(毎秒) です。

まず、何もしていない状態を測ります。

bash
$ vmstat 1 5
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つ立てます。

bash
$ for i in 1 2 3 4; do node -e "const e=Date.now()+15000;while(Date.now()<e);" & done
$ vmstat 1 5
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個にします。

bash
$ for i in $(seq 16); do node -e "const e=Date.now()+15000;while(Date.now()<e);" & done
$ vmstat 1 5
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(毎秒の切り替え)
00約 90
44約 390
1616約 1700

プロセスを増やしても、終わる仕事の量は増えません。CPUは4つのままです。 増えるのは「切り替えの回数」だけ。 そして切り替えにもCPUを使います。

これが「並列度を上げたのに遅くなった」の正体です。 ワーカーの数は、コア数を超えて増やす意味がほとんどありません。

終わるまで待つか、止めます。

bash
$ kill $(jobs -p) 2>/dev/null; wait 2>/dev/null; echo "止めました"
止めました

kill の使い分けは kill -9 を最初に打たない — Linux深掘り にあります。

スケジューリング方式

「次にどれを走らせるか」の決め方には、いくつかの型があります。

方式決め方長所短所
先着順(FCFS)来た順単純。飢餓が起きない長いのが先頭に来ると全部待つ(護送船団効果)
短いものから(SJF)予想実行時間が短い順平均待ち時間が理論上最小長いものが永久に待つ(飢餓)。実行時間は事前に分からない
ラウンドロビン一定時間ずつ順番に回す公平。応答が均等時間を短くすると切り替えコストが増える
優先度つき優先度の高い順大事な仕事を先に低優先度が飢える(対策: 待つほど優先度を上げる)

Linux の既定は長く CFS(完全公平スケジューラ)で、6.6 以降はその後継の EEVDF で、大まかには 「これまでCPUを使えていない人ほど先に回す」 という考え方です。 ラウンドロビンと優先度を混ぜたものだと思っておけば、最初は足ります。

優先度を実際に下げる

nice 値は -20(最優先)〜 19(最も譲る)。既定は 0 です。 下げる(数字を大きくする)のは誰でもできますが、上げるには root が要ります。

同じ仕事を2つ、優先度を変えて走らせます。

bash
$ node -e "const e=Date.now()+30000;while(Date.now()<e);" &
$ nice -n 19 node -e "const e=Date.now()+30000;while(Date.now()<e);" &
$ top -b -n 1 | head -12
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つに増やします。

bash
$ kill $(jobs -p) 2>/dev/null; wait 2>/dev/null
$ for i in 1 2 3 4 5; do node -e "const e=Date.now()+30000;while(Date.now()<e);" & done
$ nice -n 19 node -e "const e=Date.now()+30000;while(Date.now()<e);" &
$ sleep 5; top -b -n 1 | head -14
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 です。

bash
$ renice -n 19 -p 2902
2902 (process ID) old priority 0, new priority 19

確認します。

bash
$ sleep 5; top -b -n 1 | head -12 | tail -6
    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 を付けます。 止めるのではなく、譲らせるのがポイントです。仕事は進みますが、他の邪魔をしません。

bash
$ kill $(jobs -p) 2>/dev/null; wait 2>/dev/null; echo "止めました"
止めました

📸 スクリーンショット3: nice -n 19 を付けたプロセスだけ %CPU が一桁になっている top の出力。 NI 列と %CPU 列が並んで見えるところを残す


⑧ メモリ管理 — 全員が「メモリは全部自分のもの」と思っている

仮想メモリ

各プロセスは、「メモリの先頭から末尾まで、全部自分が持っている」と思い込んでいます。

これは嘘です。 OS と CPU がアドレスの読み替えをやっています。

プロセスAが見ているアドレス 0x1000  →  実メモリの 0x7A3F000
プロセスBが見ているアドレス 0x1000  →  実メモリの 0x2C11000

同じ「0x1000」でも、指している実メモリは別です。 だから プロセスAは、どうやってもプロセスBのメモリを読めません。 これが「プロセスは安全」の中身です。

読み替えはページという固定サイズ(普通4KB)の単位でやります。これがページングです。

bash
$ getconf PAGESIZE
4096

この仕組みのおかげでできること。

できること中身
プロセスの隔離他人のメモリに触れない
実メモリより大きく見せる使っていないページはディスクへ追い出す(スワップ)
同じものを二重に持たないlibc などの共有ライブラリは実メモリ上に1つ。全プロセスが同じページを見る
確保しても使うまで載らないmalloc した瞬間には実メモリを使わない(遅延割り当て)

free -h を読む

bash
$ 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 を全部足すと、実メモリを超える

実演します。

bash
$ ps -eo rss= | awk '{sum += $1} END {print "RSSの合計: " sum/1024 " MiB"}'
$ free -m | awk '/^Mem:/ {print "実メモリ  : " $2 " MiB (うち used " $3 " MiB)"}'
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)を使います。 共有分を人数で割った値です。

bash
$ sudo awk '/^Pss:/ {sum += $2} END {print "PSSの合計: " sum/1024 " MiB"}' /proc/*/smaps_rollup 2>/dev/null
PSSの合計: 701.16 MiB

701 MiB。free の used(684 MiB)とほぼ一致しました。

「メモリを一番食っているのは誰か」を RSS で探すのは、目安としては使えます。 でも「全部足したら何MB」を RSS でやると必ず間違えます。

/proc/meminfo

free はここを読んで整形しているだけです。

bash
$ head -8 /proc/meminfo
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 は使っていないページをディスクへ追い出します。 これがスワップです。

bash
$ grep -E "^(Swap(Total|Free)|MemAvailable)" /proc/meminfo
$ cat /proc/sys/vm/swappiness
MemAvailable:    3056640 kB
SwapTotal:       2097148 kB
SwapFree:        2097148 kB
60

メモリとディスクの速度差は、だいたい1000倍以上です。

場所だいたいの読み出し時間
CPUキャッシュ1ナノ秒 前後
メインメモリ100ナノ秒 前後
SSD100マイクロ秒 前後(メモリの約1000倍)
ハードディスク10ミリ秒 前後(メモリの約10万倍)

「サーバーが急に何をしても遅くなった」の代表がスワップです。 vmstat の si / so(swap in / swap out)が0以外になり続けていたら、それです。 CPU使用率は低いのに遅い、という形で出ます。 CPUは待っているだけだからです。

確認のしかたです。

bash
$ vmstat 1 3
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 です。

bash
$ dmesg | grep -i oom | tail -5
(何も出ない)

出なければ、この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深掘り にあります。


判断表 — プロセスか、スレッドか、非同期か

最後に、実際に選ぶときの表です。

まず、非同期で足りるかを確かめます。 測りました。

bash
$ nano async-vs-worker.mjs
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');
bash
$ node async-vs-worker.mjs
待つ仕事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_threadsCPUを本当に使う。数はコア数まで
落ちても他を巻き込みたくない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 を見てください。 そこが小さいときだけ、本当に足りていません。


後片づけ

まず、走りっぱなしのプロセスが無いか確認します。

bash
$ jobs
$ ps -ef | grep "[n]ode" | head
(何も出なければOK)

残っていたら止めます。

bash
$ pkill -f "while(Date.now()" 2>/dev/null; echo "終了コード: $?"
終了コード: 1

1 は「該当なし」です。 何も残っていなかったということなので、正常です。

作業フォルダを消します。

bash
$ cd ~
$ rm -rf ~/cslab/proc
$ ls ~/cslab
(空、または他の記事のフォルダ)

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で詰まっていることを測ってから

参考リンク


次に読む

この記事は 【深掘り】コンピュータ科学 の 18 / 25 本目です。

記事
← 前の記事PとNP・NP完全 — 答え合わせは一瞬なのに解けない
→ 次の記事デザインパターンとDI — テストが書けないのは設計のせい

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

›CS — Processes & Threads
  • 競合状態を実際に起こす
  • ロック・スケジューリング・仮想メモリ

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次