全部やるか、1つもやらないか — トランザクションとACID

トランザクションとACID。データベースと一組の処理カード、確定チェックと戻る矢印。

処理の途中で落ちたら、データはどうなるのか。全部やるか1つもやらないかを保証する仕組みを、実際に途中で落として確かめます。

前回: キャッシュは消すのが一番難しい — Redisの導入 作業場所はVMの中(Ubuntu Server)です。appdb(tasks / users / sessions)と ~/server の Express + Knex が動いている状態から始めます。

MySQLの回で、こう書いて逃げた箇所があります。

データベースは、この対策として「全部やるか、1つもやらないか」を保証します。トランザクションと呼ばれる仕組みです(この記事では扱いませんが、名前だけ覚えておいてください)。

この回が、その宿題の回収です。

そして正直に言うと、この仕組みは名前を覚えても1ミリも身に付きません。 「原子性」「一貫性」と書かれた説明を10回読んでも、自分のデータが実際に壊れるところを見るまでは、他人事のままです。

なので、壊します。

  • 送金の途中でプロセスを殺して、3000円を消滅させます
  • ターミナルを2つ開いて、在庫が1個しかない商品を2人に買わせます
  • わざとデッドロックを起こして、片方のトランザクションを強制的に殺されます

そのうえで、それぞれを直します。 障害対応の回と同じで、自分で壊したものしか、自分では直せません。

似たタイトルの記事があります。役割が違います。 この記事はアプリから使うトランザクションを扱います。トランザクションとACID|ROLLBACKしても戻らない場合 はROLLBACKしても戻らない場合と、その理屈を扱います。

対象レベル: 初級〜中級 / 区分: 必修

目次

この記事でわかること

  • トランザクションは「速くする仕組み」でも「便利な書き方」でもなく、「壊れ方を1種類に限定する仕組み」だということ
  • ACIDは覚える用語ではなく、「これが無いと何が起きるか」の一覧だということ
  • 1人で試している限り、絶対に見つからないバグがあること。在庫が1個なのに2人が買えるのは、SELECT して UPDATE する普通のコードで起きること
  • デッドロックはバグではなく、正常に起きること。正しい対処は「起きないようにする」ではなく「起きたら再試行する」だということ
  • トランザクションを長く持つと、自分だけでなくサーバー全体が止まること

この記事でやること

  1. 練習用の表(口座と在庫)を、マイグレーションで作る
  2. 2つの UPDATE の間でプロセスをわざと殺して、お金が消えることを確認する
  3. START TRANSACTION / COMMIT / ROLLBACK を、mysql の中で手で打つ
  4. ターミナルを2つ開いて競合させる。 在庫1個を2人に売ってしまい、SELECT ... FOR UPDATE で直す
  5. デッドロックを自分で起こし、Knex 側に再試行を書く

先に知る言葉

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

言葉意味
トランザクションまとめて1つとして扱ってほしい、複数の操作のかたまり。 「全部成功したことにする」か「全部無かったことにする」かの2つしか結果が無い
コミット(COMMIT)「ここまでを確定してよい」と宣言すること。 これを打つまで、書き換えは他の人に見えていない
ロールバック(ROLLBACK)「無かったことにする」。 トランザクションを始める前の状態に戻る
ロック「いま自分が触っているので、他の人は待ってください」の札。 データベースが自動で掛ける
デッドロックAがBを待ち、BがAを待って、どちらも永遠に進めない状態。 相打ち
InnoDBMySQL が標準で使っている保存の仕組みの名前。トランザクションを使えるのは、これのおかげ

「トランザクション」は、日本語だと「取引」です。 買い物のレジを思い出してください。「代金を受け取る」と「商品を渡す」は、片方だけ起きてはいけません。 その「片方だけは無し」をデータベースにやらせる仕組み、と思ってください。

① 練習用の表を作る

tasks で送金の練習はできないので、口座と在庫の表を足します。

ORMの回でやったとおり、ALTER TABLE や CREATE TABLE は手で打ちません。 マイグレーションとして残します。

bash
$ cd ~/server
$ node --env-file=.env.migrate node_modules/knex/bin/cli.js migrate:make add_accounts_and_items
Created Migration: /home/ユーザー名/server/migrations/20260907101500_add_accounts_and_items.js
bash
$ nano ~/server/migrations/*_add_accounts_and_items.js
exports.up = async function (knex) {
  await knex.schema.createTable("accounts", (t) => {
    t.increments("id");
    t.string("name", 50).notNullable();
    t.integer("balance").notNullable().defaultTo(0);
  });

  await knex.schema.createTable("items", (t) => {
    t.increments("id");
    t.string("name", 50).notNullable();
    t.integer("stock").notNullable().defaultTo(0);
  });
};

exports.down = async function (knex) {
  await knex.schema.dropTableIfExists("items");
  await knex.schema.dropTableIfExists("accounts");
};
bash
$ node --env-file=.env.migrate node_modules/knex/bin/cli.js migrate:latest
Batch 3 run: 1 migrations

.env.migrate(appmigrator)を使うところです。 .env(appuser)では CREATE command denied で止まります。それが正しい動きでした。

中身を入れます。ここからは appuser で構いません。

bash
$ mysql -u appuser -p appdb
INSERT INTO accounts (name, balance) VALUES ('あきら', 10000), ('ひかる', 0);
INSERT INTO items (name, stock) VALUES ('限定マグカップ', 1);
SELECT * FROM accounts;
+----+-----------+---------+
| id | name      | balance |
+----+-----------+---------+
|  1 | あきら    |   10000 |
|  2 | ひかる    |       0 |
+----+-----------+---------+

合計10000円です。この数字を覚えておいてください。 exit で抜けます。

② 途中で落とす —— 3000円が消える

あきら → ひかる に 3000円を送ります。 やることは2つです。

  1. あきらの残高を 3000 減らす
  2. ひかるの残高を 3000 増やす

素直に書くと、こうなります。

bash
$ nano ~/server/transfer.js
const knex = require("knex")(require("./knexfile").development);

async function transfer() {
  await knex("accounts").where({ id: 1 }).decrement("balance", 3000);
  console.log("① あきらから引き落としました");

  if (process.env.CRASH === "1") {
    console.log("💥 ここでサーバーが落ちます");
    process.exit(1);
  }

  await knex("accounts").where({ id: 2 }).increment("balance", 3000);
  console.log("② ひかるへ入金しました");

  await knex.destroy();
}

transfer();

まず、普通に動かします。

bash
$ node --env-file=.env transfer.js
① あきらから引き落としました
② ひかるへ入金しました

残高を見ます。

bash
$ mysql -u appuser -p appdb -e "SELECT id, name, balance FROM accounts;"
+----+-----------+---------+
| id | name      | balance |
+----+-----------+---------+
|  1 | あきら    |    7000 |
|  2 | ひかる    |    3000 |
+----+-----------+---------+

合計10000円。正しいです。 戻しておきます。

bash
$ mysql -u appuser -p appdb -e "UPDATE accounts SET balance = 10000 WHERE id = 1; UPDATE accounts SET balance = 0 WHERE id = 2;"

ここからが本番です

CRASH=1 を付けると、2つの UPDATE の間で process.exit(1) が走ります。

これは「エラーが出た」ではありません。 process.exit はその場でプロセスを消します。 catch も finally も動きません。電源ケーブルを抜いたのと、ほぼ同じです。

bash
$ CRASH=1 node --env-file=.env transfer.js
① あきらから引き落としました
💥 ここでサーバーが落ちます

残高を見ます。

bash
$ mysql -u appuser -p appdb -e "SELECT id, name, balance FROM accounts;"
+----+-----------+---------+
| id | name      | balance |
+----+-----------+---------+
|  1 | あきら    |    7000 |
|  2 | ひかる    |       0 |
+----+-----------+---------+

合計が 7000円になっています。3000円が、どこにも無くなりました。

[スクリーンショット: 01_消えた3000円.png] CRASH=1 を付けて実行した直後の SELECT の結果を撮ってください。合計が 10000 ではなく 7000 になっているところが読めれば十分です。

ここで大事なのは、「データベースが壊れた」わけではないことです。

MySQL は言われたことを正確にやりました。 「あきらの残高を 7000 にしろ」と言われたので、そうしました。壊したのは、こちらのコードです。

UPDATE を2回打つコードは、「1回目だけ実行される」という結末を必ず持っています。 サーバーが落ちる、ネットワークが切れる、OOM Killer にプロセスが殺される、VMが再起動する。どれも実際に起きます。 問題は「落ちること」ではなく、「落ちたときに中途半端な状態が残ること」です。

残高を戻しておきます。

bash
$ mysql -u appuser -p appdb -e "UPDATE accounts SET balance = 10000 WHERE id = 1; UPDATE accounts SET balance = 0 WHERE id = 2;"

③ START TRANSACTION / COMMIT / ROLLBACK

先に、道具そのものを手で触ります。 アプリを挟むと、何が効いているのか分からなくなるためです。

bash
$ mysql -u appuser -p appdb
START TRANSACTION;
UPDATE accounts SET balance = balance - 3000 WHERE id = 1;
UPDATE accounts SET balance = balance + 3000 WHERE id = 2;
SELECT id, name, balance FROM accounts;
+----+-----------+---------+
| id | name      | balance |
+----+-----------+---------+
|  1 | あきら    |    7000 |
|  2 | ひかる    |    3000 |
+----+-----------+---------+

変わって見えます。 ここで、気が変わったことにします。

ROLLBACK;
SELECT id, name, balance FROM accounts;
+----+-----------+---------+
| id | name      | balance |
+----+-----------+---------+
|  1 | あきら    |   10000 |
|  2 | ひかる    |       0 |
+----+-----------+---------+

戻りました。

「変わって見えた」のは、自分にだけです。 COMMIT するまで、他の接続からは古いままに見えています。 これは後で、ターミナルを2つ開いて実際に確かめます。 ROLLBACK は「取り消し機能」ではありません。 そもそもまだ確定していなかった、というのが正確な言い方です。

今度は確定させます。

START TRANSACTION;
UPDATE accounts SET balance = balance - 3000 WHERE id = 1;
UPDATE accounts SET balance = balance + 3000 WHERE id = 2;
COMMIT;

COMMIT を打った瞬間に、他の全員から見えるようになります。 そして、もう ROLLBACK では戻せません。

ROLLBACK;
SELECT id, name, balance FROM accounts;

7000 と 3000 のままです。 エラーも出ません。「戻すものが無い」からです。

戻しておきます。

UPDATE accounts SET balance = 10000 WHERE id = 1;
UPDATE accounts SET balance = 0 WHERE id = 2;

打っていないのに、いつもコミットされている理由

ここまで、INSERT や UPDATE を COMMIT 無しで打ってきました。それでも保存されていました。

SELECT @@autocommit;
+--------------+
| @@autocommit |
+--------------+
|            1 |
+--------------+

MySQL は既定で「1文ごとに、勝手に COMMIT する」動きになっています(autocommit)。 つまりトランザクションが無いのではなく、「1文だけのトランザクション」が毎回張られている、というのが正しい理解です。 START TRANSACTION は、その自動コミットを「COMMIT を打つまで待て」に切り替える宣言です。

exit で抜けます。

④ もう一度、途中で落とす

transfer.js を、トランザクション付きに書き換えます。

bash
$ nano ~/server/transfer.js
const knex = require("knex")(require("./knexfile").development);

async function transfer() {
  const trx = await knex.transaction();
  try {
    await trx("accounts").where({ id: 1 }).decrement("balance", 3000);
    console.log("① あきらから引き落としました(まだ確定していません)");

    if (process.env.CRASH === "1") {
      console.log("💥 ここでサーバーが落ちます");
      process.exit(1);
    }

    await trx("accounts").where({ id: 2 }).increment("balance", 3000);
    await trx.commit();
    console.log("② 確定しました");
  } catch (err) {
    await trx.rollback();
    throw err;
  }

  await knex.destroy();
}

transfer();

同じように殺します。

bash
$ CRASH=1 node --env-file=.env transfer.js
① あきらから引き落としました(まだ確定していません)
💥 ここでサーバーが落ちます
bash
$ mysql -u appuser -p appdb -e "SELECT id, name, balance FROM accounts;"
+----+-----------+---------+
| id | name      | balance |
+----+-----------+---------+
|  1 | あきら    |   10000 |
|  2 | ひかる    |       0 |
+----+-----------+---------+

10000円のままです。引き落としも無かったことになりました。

ここが、この記事で一番大事なところです。

catch は動いていません。rollback() も呼ばれていません。 process.exit はそれを許しません。 にもかかわらず戻ったのは、MySQL側が戻したからです。

COMMIT されないまま接続が切れたトランザクションは、MySQLが自動的にロールバックします。 だから 「アプリが正しく後始末をすること」に依存していません。 VMの電源を引っこ抜いても同じです。

これが、try / catch で頑張るのとの決定的な違いです。 catch は、プロセスが生きているときにしか動きません。

CRASH を付けずに動かして、正常系も確認しておきます。

bash
$ node --env-file=.env transfer.js
$ mysql -u appuser -p appdb -e "SELECT id, name, balance FROM accounts;"

7000 と 3000。 戻しておきます。

bash
$ mysql -u appuser -p appdb -e "UPDATE accounts SET balance = 10000 WHERE id = 1; UPDATE accounts SET balance = 0 WHERE id = 2;"

⑤ ACIDを、「守られないと何が起きるか」で読む

教科書には「原子性・一貫性・独立性・永続性」と書いてあります。この4語を覚えても、何の役にも立ちませんでした。

役に立ったのは、「これが無いと、どう壊れるか」で読み直したときです。

A — Atomicity(原子性)/ 無いと「片道だけ」が残る

いま見たやつです。 引き落としたのに入金されていない。3000円が消える。

  • 守られると: 2つの UPDATE は、両方起きるか、両方起きないかしかない
  • 確かめ方: さっきの CRASH=1

C — Consistency(一貫性)/ 無いと「ありえない値」が残る

残高がマイナスの口座。存在しないユーザーに紐づくタスク。在庫 -1。

これは「トランザクションを張れば自動で守られる」ものではありません。 ここだけ性質が違います。

一貫性は、「あなたがルールを書けば、トランザクションの終わりでそれが守られていることを保証する」という意味です。 ルールを書くのは、あなたです。

ALTER TABLE accounts ADD CONSTRAINT chk_balance CHECK (balance >= 0);

(これは appmigrator の仕事なので、ここでは打たずに読むだけで構いません。) こう書いておけば、残高をマイナスにする UPDATE はエラーになり、トランザクションごと巻き戻ります。

  • 守られないと: WHERE balance >= 3000 を書き忘れたコードが、残高 -3000 の口座を作る
  • 道具: NOT NULL / CHECK / UNIQUE / 外部キー。ORMの回で書いたマイグレーションが、そのまま一貫性の担保です

I — Isolation(独立性)/ 無いと「他人の途中経過」が見える

これが一番やっかいで、この記事の山場です。

同時に動いている他のトランザクションの、まだ確定していない書き換えが見えてしまう。 あるいは、見えていないせいで、上書きしてしまう。

  • 守られないと: 在庫1個の商品が、2人に売れる(次の章で実際にやります)
  • 確かめ方: ターミナルを2つ開く。1つでは絶対に再現しません

D — Durability(永続性)/ 無いと「COMMITしたのに消える」

COMMIT が返ってきたなら、その直後に電源が落ちても残っている、という約束です。

  • 守られないと: 「保存しました」と画面に出したのに、再起動したら無い
  • どうやって守っているか: MySQL は先に「これから何をするか」をディスクのログに書いてから、実際のデータを書きます。落ちても、起動時にログを読み直して続きをやります

COMMIT が「速くない」のは、これが理由です。 ディスクへの書き込みを待っています。 1件ずつ COMMIT する1万回のループが異常に遅いのは、1万回ディスクを待っているからです。まとめて1つのトランザクションにすると、劇的に速くなります。

⑥ 在庫1個を、2人が買えてしまう

ここからは、ターミナルを2つ使います。

VS Code のターミナルを2つに割ってもいいですし、VS CodeのRemote SSHで繋いだウィンドウを2枚開いても構いません。 同じVMに、別々のセッションで入っていることだけが条件です。

以下、ターミナルA と ターミナルB と書きます。どちらで打つかを必ず見てください。

両方で MySQL に入ります。

ターミナルA

bash
$ mysql -u appuser -p appdb

ターミナルB

bash
$ mysql -u appuser -p appdb

在庫を1に戻しておきます。

ターミナルA

UPDATE items SET stock = 1 WHERE id = 1;
SELECT * FROM items;
+----+-----------------------+-------+
| id | name                  | stock |
+----+-----------------------+-------+
|  1 | 限定マグカップ        |     1 |
+----+-----------------------+-------+

普通のコードは、こう書かれています

「買う」処理を素直に書くと、必ずこうなります。

  1. 在庫を見る(SELECT)
  2. 1個以上あれば、在庫を減らす(UPDATE)

この2手が、事故のもとです。

実際に事故を起こす

上から順に、AとBを交互に打ってください。 1行ずつ、指示された側で打つのが大事です。

ターミナルA —— お客さん1号が商品ページを開いた

START TRANSACTION;
SELECT stock FROM items WHERE id = 1;
+-------+
| stock |
+-------+
|     1 |
+-------+

「1個ある。買える」と判断しました。

ターミナルB —— お客さん2号が、ほぼ同時に開いた

START TRANSACTION;
SELECT stock FROM items WHERE id = 1;
+-------+
| stock |
+-------+
|     1 |
+-------+

Bにも「1個ある」と見えています。 待たされません。一瞬で返ります。

ターミナルA —— 1号が購入ボタンを押した

UPDATE items SET stock = 0 WHERE id = 1;
COMMIT;

ターミナルB —— 2号も購入ボタンを押した

UPDATE items SET stock = 0 WHERE id = 1;
COMMIT;

両方とも成功します。エラーは1つも出ません。

ターミナルA

SELECT * FROM items;
+----+-----------------------+-------+
| id | name                  | stock |
+----+-----------------------+-------+
|  1 | 限定マグカップ        |     0 |
+----+-----------------------+-------+

在庫は 0。そして、注文は2件入りました。1個しかない商品が、2人に売れました。

[スクリーンショット: 02_二人が同時に買えた.png] ターミナルAとBを左右に並べて、両方の SELECT stock が 1 を返しているところと、両方の UPDATE が成功しているところを1枚に撮ってください。

これを「ロストアップデート(更新の喪失)」と呼びます。 Aがやった更新が、Bに知られないまま上書きされました。

恐ろしいのは、テストで見つからないことです。 1人で何回押しても、絶対に再現しません。 負荷分散の回でアプリを2つに増やしましたが、こういうバグは、その瞬間から起きる確率が上がります。

そして、START TRANSACTION を書いてあっても防げていないことに注目してください。

トランザクションは「同時に触られること」を自動では防ぎません。 「途中で落ちること」は自動で守ってくれますが、「同時に来ること」は、こちらが指示しないと守ってくれません。

直す —— SELECT … FOR UPDATE

SELECT に FOR UPDATE を足します。 意味は「この行、これから書き換えるので押さえておいてください」です。

在庫を戻します。

ターミナルA

UPDATE items SET stock = 1 WHERE id = 1;

ターミナルA —— 1号

START TRANSACTION;
SELECT stock FROM items WHERE id = 1 FOR UPDATE;
+-------+
| stock |
+-------+
|     1 |
+-------+

すぐ返ります。

ターミナルB —— 2号

START TRANSACTION;
SELECT stock FROM items WHERE id = 1 FOR UPDATE;

ここで、Bが止まります。 プロンプトが返ってきません。これが正しい動きです。

[スクリーンショット: 03_for_updateで待つ.png] ターミナルBが SELECT ... FOR UPDATE; を打ったまま止まっているところを撮ってください。AとBを並べて、Aは入力待ちに戻っていることが分かると理想です。

ターミナルA —— 1号が買う

UPDATE items SET stock = stock - 1 WHERE id = 1;
COMMIT;

COMMIT した瞬間、ターミナルBの待ちが解けます。

ターミナルB

+-------+
| stock |
+-------+
|     0 |
+-------+

Bには 0 が返りました。 Bのアプリは、ここで「売り切れです」と返すべきです。

ターミナルB

ROLLBACK;

事故が防げました。

FOR UPDATE が何をしたのか。 「読んだ行にロックを掛けた」だけです。そのロックは COMMIT か ROLLBACK まで続きます。 だからBは、Aが終わるまで待たされ、待ってから読んだので、最新の在庫を見ることができました。

普通の SELECT はロックを掛けません。だから待たされず、古い値で判断してしまいました。

もっと簡単な直し方もある

在庫を1つ減らすだけなら、SELECT を挟まずに1文で書けます。

UPDATE items SET stock = stock - 1 WHERE id = 1 AND stock > 0;

そして「何行変わったか」を見ます。

SELECT ROW_COUNT();
  • 1 が返った → 買えた
  • 0 が返った → 在庫が無かった。売り切れとして扱う

UPDATE は、1文の中で自動的にロックを掛けます。 だから読んで判断して書く、の隙間が存在しません。

できるなら、こちらのほうが速くて安全です。 ロックしている時間が桁違いに短いからです。 FOR UPDATE が要るのは、「読んだ値をもとに、他の表も書き換える」ような、1文にできない処理です。 Knex なら、.update() の戻り値がそのまま件数です。if (count === 0) で分岐できます。

⑦ 分離レベル —— 「何が見えるか」の設定

さっきの事故は、「他人の途中経過が、どこまで見えるか」の設定と関係しています。これを分離レベルと呼びます。

用語を並べても頭に入らないので、「何が見えるか」だけで書きます。

設定何が見えるか
READ UNCOMMITTED他人がまだ COMMIT していない書き換えまで見える。 相手が ROLLBACK したら、見た値は幻。使いません
READ COMMITTED確定したものだけ見える。 ただし同じ SELECT を2回打つと、答えが変わることがある(間に他人が COMMIT すると)
REPEATABLE READトランザクションを始めた時点の景色が、最後まで変わらない。 同じ SELECT は何度打っても同じ答え。MySQLの既定
SERIALIZABLE順番に1つずつ実行したのと同じ結果になる。一番安全で、一番待たされる

いまの設定を確認します。

ターミナルA

SELECT @@transaction_isolation;
+-------------------------+
| @@transaction_isolation |
+-------------------------+
| REPEATABLE-READ         |
+-------------------------+

「景色が変わらない」を、目で見る

ターミナルA

START TRANSACTION;
SELECT balance FROM accounts WHERE id = 1;
+---------+
| balance |
+---------+
|   10000 |
+---------+

Aは、そのまま置いておきます。

ターミナルB —— 別の誰かが入金した

UPDATE accounts SET balance = 99999 WHERE id = 1;

(autocommit なので、これで確定しています。)

ターミナルA —— もう一度、同じものを見る

SELECT balance FROM accounts WHERE id = 1;
+---------+
| balance |
+---------+
|   10000 |
+---------+

10000 のままです。 Bが確定させた 99999 は、Aには見えません。

ターミナルA

COMMIT;
SELECT balance FROM accounts WHERE id = 1;
+---------+
| balance |
+---------+
|   99999 |
+---------+

トランザクションを終えたら、見えました。

これが REPEATABLE READ です。 「集計している途中で数字が動かない」のが利点です。合計と内訳を別々に SELECT しても、辻褄が合います。

ただし、書くときは最新を見ます

ここが最大の落とし穴です。

さっきAには「10000」に見えていました。では、Aがトランザクションの中で UPDATE したら、10000 を基準に書き換わるのでしょうか。

違います。

普通の SELECT は「始めた時点の景色」を見ますが、UPDATE / DELETE / SELECT ... FOR UPDATE は、必ず「いまの最新」を見て、ロックを掛けます。

だから、⑥の在庫の事故が起きました。 SELECT が古い景色を返し、その古い値をアプリが信じて UPDATE stock = 0 と決め打ちしたからです。

そして、こう書けば事故は起きませんでした。

UPDATE items SET stock = stock - 1 WHERE id = 1 AND stock > 0;

stock - 1 は、データベースが最新の値を読んで計算します。 アプリが読んだ古い値は、どこにも出てきません。

分離レベルを上げれば安全になる、ではありません。 上げると待ち時間が伸び、負荷分散の回で見たとおり、詰まる場所が増えます。 既定の REPEATABLE READ のまま、必要なところにだけ FOR UPDATE を置くのが、実際によく使われるやり方です。

戻しておきます。

ターミナルA

UPDATE accounts SET balance = 10000 WHERE id = 1;
UPDATE accounts SET balance = 0 WHERE id = 2;
UPDATE items SET stock = 1 WHERE id = 1;

⑧ デッドロックを、自分で起こす

ロックを掛けると、今度は別の問題が出ます。

2つのターミナルで、同じ2行を「逆の順番で」触ります。

ターミナルA

START TRANSACTION;
UPDATE accounts SET balance = balance - 1 WHERE id = 1;

(成功します。Aが 1番の行を押さえました。)

ターミナルB

START TRANSACTION;
UPDATE accounts SET balance = balance - 1 WHERE id = 2;

(成功します。Bが 2番の行を押さえました。)

ターミナルA —— 今度は 2番を触る

UPDATE accounts SET balance = balance + 1 WHERE id = 2;

Aが止まります。 2番はBが持っているので、待ちに入りました。

ターミナルB —— 今度は 1番を触る

UPDATE accounts SET balance = balance + 1 WHERE id = 1;

片方に、これが出ます。

ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction

[スクリーンショット: 04_デッドロック.png] ERROR 1213 が出ている側のターミナルを撮ってください。もう一方が待ちから解放されているところも一緒に写ると理想です。

もう片方の待ちは、解けています。

MySQL は、AとBが互いに待ち合っていることを検出しました。 放っておくと永遠に終わらないので、片方を強制的に殺しました。 殺されたほうは、トランザクションまるごとロールバックされています。 「エラーが出た」のではなく、「データベースが正しく仕事をした」というのが、この現象の読み方です。

残ったほうを片づけます。

ターミナルA(エラーが出ていないほう)

ROLLBACK;

エラーが出たほうも ROLLBACK; を打っておいてください。 すでに巻き戻っていますが、トランザクションを閉じておくためです。

正しい対処は2つ

① ロックの順番を、みんなで揃える

Aは 1 → 2、Bは 2 → 1 の順で触ったのが原因でした。 常に id の小さい順に触ると決めれば、この形のデッドロックは起きません。

// 送金でも、必ず id の小さいほうから触る
const ids = [fromId, toId].sort((a, b) => a - b);
for (const id of ids) {
  await trx("accounts").where({ id }).forUpdate().first();
}

② それでも起きるので、再試行する

順番を揃えても、索引の張り方や実行計画によってデッドロックは起きます。ゼロにはできません。

だから、正しい対処は「起こさないようにする」ではなく「起きたら、もう一度やる」です。 トランザクションは丸ごと巻き戻っているので、そのまま最初からやり直しても安全です。 二重に引き落とされることはありません。 これが try / catch で握りつぶしていい唯一の例外ではなく、「握りつぶさずに、もう一度やる」という意味です。

⑨ Knex でトランザクションを書く

アプリ側です。「送金API」を app.js に足します。

// デッドロック(1213)なら、少し待って最初からやり直す
async function withRetry(fn, times = 3) {
  for (let i = 0; i < times; i++) {
    try {
      return await fn();
    } catch (err) {
      if (err.errno === 1213 && i < times - 1) {
        console.warn(`[deadlock] ${i + 1}回目。やり直します`);
        await new Promise((resolve) => setTimeout(resolve, 50 * (i + 1)));
        continue;
      }
      throw err;
    }
  }
}

app.post("/api/transfer", requireLogin, async (req, res) => {
  const { fromId, toId, amount } = req.body;

  if (!Number.isInteger(amount) || amount <= 0) {
    return res.status(400).json({ error: "amount は1以上の整数です" });
  }

  try {
    await withRetry(() =>
      knex.transaction(async (trx) => {
        // 小さい id から押さえる(デッドロック回避)
        for (const id of [fromId, toId].sort((a, b) => a - b)) {
          await trx("accounts").where({ id }).forUpdate().first();
        }

        const from = await trx("accounts").where({ id: fromId }).first();
        if (!from) throw new Error("送金元がありません");
        if (from.balance < amount) throw new Error("残高不足");

        await trx("accounts").where({ id: fromId }).decrement("balance", amount);
        await trx("accounts").where({ id: toId }).increment("balance", amount);
      })
    );
    res.status(204).end();
  } catch (err) {
    console.error(err);
    res.status(400).json({ error: err.message });
  }
});

動かします。

bash
$ cd ~/server && node --env-file=.env app.js
bash
$ curl -s -c cookie.txt -X POST http://localhost:3000/api/login \
    -H "Content-Type: application/json" \
    -d '{"email":"me@example.com","password":"pass12345"}' | jq
$ curl -s -o /dev/null -w "%{http_code}\n" -b cookie.txt -X POST http://localhost:3000/api/transfer \
    -H "Content-Type: application/json" -d '{"fromId":1,"toId":2,"amount":3000}'
$ mysql -u appuser -p appdb -e "SELECT id, name, balance FROM accounts;"

204 が返り、7000 と 3000 になっていれば成功です。

残高不足も試します。

bash
$ curl -s -b cookie.txt -X POST http://localhost:3000/api/transfer \
    -H "Content-Type: application/json" -d '{"fromId":1,"toId":2,"amount":999999}' | jq
{
  "error": "残高不足"
}

残高は動いていません。 throw すると、Knex が自動で ROLLBACK します。

コールバック形式(knex.transaction(async (trx) => { ... }))の利点は、これです。 中で例外が飛べば自動でロールバック、最後まで通れば自動でコミット。 commit() の書き忘れが起きません。

await を置き忘れる場所が、3つあります

トランザクションの事故は、ほぼ全部これです。 エラーが出ないまま、静かに壊れます。

① knex.transaction(...) の前

// 壊れている
knex.transaction(async (trx) => { ... });
res.status(204).end();

await が無いので、トランザクションが終わる前に 204 を返します。 利用者には「成功しました」と出て、そのあと中で失敗しても、誰にも伝わりません。 さらに catch にも入らないので、ログにすら残らないことがあります。

② トランザクションの中の各クエリの前

// 壊れている
trx("accounts").where({ id: fromId }).decrement("balance", amount);
await trx("accounts").where({ id: toId }).increment("balance", amount);

1行目に await がありません。 コールバックはそのまま最後まで走り、Knex は「終わった」と判断して COMMIT します。 await されていないクエリビルダは実行されないので、引き落としは送られず、入金だけが確定します。 お金が増えます。

③ trx ではなく knex を使ってしまう

// 壊れている
await knex("accounts").where({ id: toId }).increment("balance", amount);

trx と書くべきところが knex になっています。 これは別の接続なので、トランザクションの外側で実行され、ロールバックの対象になりません。

さらに悪いことに、同じ行を触ると自分自身のロックを待ちます。 自分が持っているロックを、自分が待つという形になり、50秒待たされて ERROR 1205 (Lock wait timeout exceeded) になります。

見分け方は簡単です。トランザクションの中に knex( という文字が1つでもあったら、疑ってください。 中で使ってよいのは trx( だけです。

⑩ トランザクションを長く持たない

最後に、一番よくある性能事故の話です。

やってはいけない形が、はっきりしています。

// やってはいけない
await knex.transaction(async (trx) => {
  await trx("orders").insert(order);
  await fetch("https://example.com/payment", { method: "POST" });  // ← 外部API
  await sendMail(user.email);                                       // ← メール送信
  await trx("orders").where({ id }).update({ status: "paid" });
});

外部のサービスは、遅いことがあります。3秒かかることも、30秒かかることもあります。 その間ずっと、orders の行はロックされたままです。

何が起きるか。

起きること理由
他の人の同じ行への操作が、全部待たされるロックが解けないから
待たされた側が ERROR 1205 で落ちる既定で 50秒待つと諦める
APIサーバー全体が止まる接続プールが埋まるから(次で説明します)

3つ目が、想像より深刻です。

MySQLの回で connectionLimit: 10 と書きました。 同時に使える接続は10本です。 トランザクション1つは、終わるまで接続を1本占有します。 30秒かかるトランザクションが10本走ったら、11本目以降は、ただの SELECT でも待たされます。 「データベースは全然忙しくないのに、サイト全体が固まる」は、この形で起きます。

守ることは3つです。

  1. 外部への通信・メール送信・ファイル処理を、トランザクションの中に入れない。 先にやるか、後でやる
  2. 人の入力を待たない。 「確認画面を出している間ロックしておく」は最悪です。利用者がタブを閉じたら、誰も解放できません
  3. 読むだけの処理に、トランザクションを張らない。 SELECT だけなら不要です

パフォーマンス改善の回で「測る」をやりました。 ロック待ちは、EXPLAIN には出ません。 クエリ自体は速いのに、順番待ちで遅いからです。 「1本ずつ叩くと速いのに、同時に叩くと遅い」は、索引ではなくロックを疑ってください。

待っているロックは、こう見られます。

bash
$ sudo mysql -e "SELECT * FROM performance_schema.data_locks\G"

appuser ではなく sudo mysql で打っています。 ここを見る権限を、アプリ用ユーザーには与えていないからです。これは正しい状態です。

つまずいたところ

症状原因
ROLLBACK したのに戻らないすでに COMMIT している。 確定後は戻せない。エラーも出ないので気づきにくい
START TRANSACTION を書いたのに、在庫の二重販売が防げないSELECT にロックが掛かっていない。 FOR UPDATE が要る
ターミナルBが固まった正常です。 Aが COMMIT か ROLLBACK を打つまで待ちます。Aを見てください
ERROR 1205 Lock wait timeout exceeded誰か(自分かもしれない)がロックを持ったまま COMMIT していない。 別のターミナルを閉じ忘れていないか確認
ERROR 1213 Deadlock foundバグではない。 ロールバック済みなので、そのまま再試行するのが正解
引き落としだけ確定して、入金が消えたawait の書き忘れ(②の形)。トランザクションの中の全行を確認
ロールバックされずに残った中で knex( を使っている(③の形)。trx( に直す
mysql を exit したら、ロックが消えた接続が切れると、未コミットのトランザクションは自動でロールバックされます。 ④で見たとおりです

ターミナルを2つ使う実験は、片方を閉じ忘れると次の実験が全部固まります。 おかしくなったら、両方 exit して入り直すのが一番速い解決でした。接続が切れれば、ロックも消えます。

後片づけ

実験用の表を消します。 ORMの回で書いた down が、ここで役に立ちます。

bash
$ cd ~/server
$ node --env-file=.env.migrate node_modules/knex/bin/cli.js migrate:rollback
Batch 3 rolled back: 1 migrations

練習用スクリプトも消しておきます。

bash
$ rm ~/server/transfer.js

accounts と items を残しておいても構いません。 残すなら、残高と在庫を戻しておいてください。 /api/transfer を app.js に残したまま表を消すと、呼んだときに落ちます。 どちらかに揃えてください。

まとめ

  • トランザクションは「全部やるか、1つもやらないか」。 MySQLの回で先送りにした宿題は、これで回収した
  • COMMIT しないまま接続が切れたら、MySQLが自動でロールバックする。 try / catch と違い、プロセスが死んでいても効く。これが決定的な差
  • MySQLは既定で autocommit。 トランザクションが無いのではなく、1文だけのトランザクションが毎回張られている
  • ACIDは、無いと何が起きるかで読む。 A=片道だけ残る / C=ありえない値が残る / I=他人の途中経過が見える / D=COMMITしたのに消える
  • 一貫性(C)だけは、自動で守られない。 NOT NULL や CHECK を書くのは自分。マイグレーションがその置き場所
  • START TRANSACTION は、同時アクセスを防がない。 在庫1個が2人に売れる事故は、トランザクションを書いていても起きる
  • SELECT ... FOR UPDATE で行を押さえる。 ただし 1文で UPDATE ... WHERE stock > 0 と書けるなら、そのほうが速くて安全
  • 分離レベルは「何が見えるか」の設定。 MySQLの既定は REPEATABLE READ=始めた時点の景色が変わらない。ただし UPDATE と FOR UPDATE は最新を見る
  • デッドロックはバグではない。 正しい対処は「起こさない」ではなく「起きたら再試行する」。ロールバック済みなので、やり直しても二重にならない
  • await の置き忘れは、エラーを出さずに壊す。 knex.transaction の前 / 中の各クエリの前 / trx を knex と書く、の3つ
  • トランザクションを長く持たない。 外部APIもメールも入れない。接続プール10本が埋まれば、ただの SELECT まで待たされる
  • ロック待ちは EXPLAIN に出ない。 「1本なら速いのに同時だと遅い」は、索引ではなくロックを疑う

参考リンク


次に読む

この記事は 【第5段階】バックエンドとデータベース の 14 / 29 本目です。

記事
← 前の記事キャッシュは消すのが一番難しい — Redisの導入
→ 次の記事MySQLとPostgreSQLの違いは1割 — 移して確かめる

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

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

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

Backend›Databases
  • Transactions
  • ACID
  • 分離レベルとデッドロック

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

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

コメント

コメントする

目次