キャッシュの書き込み戦略 — 更新したのに古い値が返る

キャッシュの書き込み戦略。データベースとキャッシュの箱、更新マークと確認する虫眼鏡。

この記事はわざと古い値をキャッシュに残し、わざとデータを失い、わざと Redis のメモリを埋めます。 最後の「後片づけ」まで必ずやってください。maxmemory を戻し忘れると、翌日から別の用途のキーが黙って消えます。

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へ進めます。 本線の ボトルネックは動く — 負荷分散とキャッシュの設計 の続きとして、「キャッシュをいつ、どう書き換えるか」だけを、実際に実装して確かめます。

前回: キャッシュを置く5つの層 — 入れたのに速くならない

この記事のコマンドは、すべてVMの中(Ubuntu Server)で打ちます。 Windows の PowerShell では打ちません。

前提: 本線の キャッシュは消すのが一番難しい — Redisの導入を終えていて、redis-cli ping が PONG を返すこと。 MySQL も プロセスを止めても消えない場所 — MySQLとSQLの基本の回で入れたものを使います。

在庫を直しました。データベースを見ると、確かに 200 になっています。

bash
$ mysql -u appuser -p -e "SELECT stock FROM cachedb.products WHERE id = 1;"
+-------+
| stock |
+-------+
|   200 |
+-------+

なのに、画面はいつまでも 100 のままでした。リロードしても、別のブラウザで開いても 100 です。

犯人はキャッシュです。ただし「キャッシュを入れたこと」が悪かったのではありません。

前回のキャッシュをどこに置くかで、置き場所は決めました。ブラウザ・アプリの中・Redis・データベースの中、どこに何を置くかです。しかし置き場所を決めただけでは、まだ半分です。

決めていなかったのは「その置いたものを、いつ書き換えるか」でした。

読むときにどう入れるか。書くときに何をするか。書き換えるのか消すのか。いつ消えるのか。この4つを決めていないキャッシュは、必ずこの症状を出します。

この回では、読み方3つ・書き方3つを全部実装して、時間を測って比べます。 そして2つの更新が交錯して古い値が残る競合を、わざと起こします。

対象レベル: 中級〜上級 / 区分: 発展

目次

この記事でわかること

  • 「キャッシュが古い」の原因はほぼ全部、書き込み側の設計にあること。読み側をいくら直しても直らない
  • cache-aside・read-through・refresh-ahead は「誰がデータベースを読むか」だけの違いであること
  • write-behind は速いが、落ちたら書いた内容が消えること。速さの正体は「まだ書いていない」だけだということ
  • キャッシュは「書き換える」より「消す」ほうが安全であること。書き換えると2つの更新が交錯して古い値が残る
  • TTL を付けないキャッシュは、いつか必ずメモリを食い潰すこと。そして既定の maxmemory-policy は「消さずにエラーを返す」であること
  • 全部同じ TTL にすると、期限が同時に来てデータベースが跳ねること
  • キーに「誰の」を混ぜ忘れると、他人のデータが表示されること

この記事でやること

  1. 測れる土台を作る(遠くにあるデータベースを再現して、キャッシュの有無で差が出るようにする)
  2. 読み方を3つ実装して比べる(cache-aside / read-through / refresh-ahead)
  3. 書き方を3つ実装して、書き込み時間と直後の読み込み時間を実測する(write-through / write-behind / write-around)
  4. 「書き換える」で競合をわざと起こし、「消す」に変えて直す
  5. TTL 無しでメモリを埋め、maxmemory-policy を切り替えて挙動の違いを見る
  6. キーに個人を混ぜ忘れて、他人のデータが出るところまで再現して直す

先に知る言葉

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

言葉意味
cache-asideアプリがキャッシュを見て、無ければ自分でデータベースを読んで入れるやり方。遅延読み込みとも言う
read-throughキャッシュ層が代わりにデータベースを読んでくれるやり方。アプリはキャッシュにしか話しかけない
refresh-ahead期限が来る前に、裏で先に読み直しておくやり方
write-throughデータベースとキャッシュに同時に書くやり方
write-behind先にキャッシュへ書いて、データベースへは後でまとめて書くやり方。write-back とも言う
write-aroundキャッシュを飛ばしてデータベースにだけ書くやり方
無効化古くなったキャッシュを消すこと。 英語で invalidation
エビクションメモリがいっぱいのとき、Redis が勝手にキーを追い出すこと
LRU / LFULeast Recently Used(最後に使ったのが一番古い) / Least Frequently Used(使われた回数が一番少ない)。追い出す相手の選び方
スタンピード期限が同時に切れて、大量の読み込みが一斉にデータベースへ突き抜けること
ジッター期限をわざとばらつかせること。 同時に切れないようにする

6つの型は、覚えるものではありません。 「誰がデータベースを読むか」と「いつデータベースに書くか」の組み合わせが、たまたま6つの名前を持っているだけです。 名前を覚える前に、1つずつ書いて時間を測ってください。 名前は後から付いてきます。


① 測れる土台を作る

なぜ土台がいるのか

手元の MySQL は速すぎます。 同じマシンの中にいるので、1件取るのに 1ms もかかりません。この状態でキャッシュを入れても、差はほとんど出ません。

本番のデータベースは、たいていネットワークの向こうにいます。 別のサーバー、別のゾーン、ときには別のリージョンです。遅さは足し算で増えるので、往復のぶんだけ確実に上乗せされます。

そこで、往復ぶんの待ち時間をわざと足します。 数字を作るのではなく、測りたいものが見えるようにするためです。

bash
$ mkdir -p ~/sd-cache && cd ~/sd-cache
$ npm init -y
$ npm install redis mysql2
added 24 packages in 3s

package.json に1行足して、import を使えるようにします。

bash
$ npm pkg set type=module

データを用意する

bash
$ mysql -u appuser -p
CREATE DATABASE IF NOT EXISTS cachedb;
USE cachedb;

CREATE TABLE IF NOT EXISTS products (
  id    INT PRIMARY KEY,
  name  VARCHAR(100) NOT NULL,
  stock INT NOT NULL
);

INSERT INTO products (id, name, stock) VALUES
  (1, 'ノート', 100),
  (2, 'ペン',   200),
  (3, '消しゴム', 300)
ON DUPLICATE KEY UPDATE name = VALUES(name), stock = VALUES(stock);

SELECT * FROM products;
+----+--------------+-------+
| id | name         | stock |
+----+--------------+-------+
|  1 | ノート       |   100 |
|  2 | ペン         |   200 |
|  3 | 消しゴム     |   300 |
+----+--------------+-------+
3 rows in set (0.00 sec)

\q で抜けます。

データベース側

~/sd-cache/db.mjs を作ります。

import mysql from 'mysql2/promise';

// 「遠くにあるデータベース」を再現するための待ち時間(ミリ秒)
const WAN_MS = Number(process.env.WAN_MS ?? 30);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const pool = mysql.createPool({
  host: '127.0.0.1',
  user: 'appuser',
  password: process.env.DB_PASS,   // 自分が決めたパスワードを環境変数で渡す
  database: 'cachedb',
  connectionLimit: 10,
});

export let dbReads = 0;
export let dbWrites = 0;

export async function dbRead(id) {
  dbReads++;
  await sleep(WAN_MS);
  const [rows] = await pool.query(
    'SELECT id, name, stock FROM products WHERE id = ?', [id]);
  return rows[0] ?? null;
}

export async function dbWrite(id, stock) {
  dbWrites++;
  await sleep(WAN_MS);
  await pool.query('UPDATE products SET stock = ? WHERE id = ?', [stock, id]);
}

export async function closeDb() { await pool.end(); }

dbReads と dbWrites を数えているのが大事です。 速くなったかどうかより、データベースに何回行ったかのほうが、キャッシュの効きをよく表します。

キャッシュ側

~/sd-cache/cache.mjs を作ります。

import { createClient } from 'redis';

export const redis = createClient({
  url: 'redis://127.0.0.1:6379',
  password: process.env.REDIS_PASS,   // requirepass を設定した場合
});

redis.on('error', (e) => console.error('redis error:', e.message));
await redis.connect();

// この記事で作るキーは、すべて sd: で始める(後片づけのため)
export const key = (id) => `sd:product:${id}`;

export function ms(t0) { return (Number(process.hrtime.bigint() - t0) / 1e6).toFixed(1); }
export function now() { return process.hrtime.bigint(); }

キーの頭に sd: を付けているのは、後で消すためです。 FLUSHALL は、そのサーバーの全部を消します。 学習用の VM でも、別の練習で入れたセッションが一緒に消えます。 最初から接頭辞を決めておけば、後片づけは「その接頭辞だけ」で済みます。

パスワードを環境変数に入れておきます。ここから先のコマンドは、すべてこのシェルで打ちます。

bash
$ read -s -p "MySQL appuser のパスワード: " DB_PASS; echo; export DB_PASS
$ read -s -p "Redis の requirepass(未設定なら空Enter): " REDIS_PASS; echo; export REDIS_PASS

read -s は打った文字を画面に出しません。 履歴にも残らないので、export DB_PASS=xxxx と直接書くより安全です。

うまくいったかの確認は、ここで1本動かしてみます。

bash
$ node -e "import('./db.mjs').then(async m => { console.log(await m.dbRead(1)); await m.closeDb(); })"
{ id: 1, name: 'ノート', stock: 100 }

ここが出なければ先へ進めません。 Access denied ならパスワード、ECONNREFUSED なら MySQL が動いていません(systemctl status mysql)。


② 読み方の型を3つ、実装して比べる

読み方の違いは、たった一点です。「誰がデータベースを読むか」。

型1: cache-aside(遅延読み込み)— 一番多い

アプリがキャッシュを見て、無ければ自分でデータベースを読んで、自分でキャッシュに入れます。

~/sd-cache/read1-aside.mjs:

import { redis, key, now, ms } from './cache.mjs';
import { dbRead, closeDb, dbReads } from './db.mjs';

async function getAside(id) {
  const k = key(id);
  const hit = await redis.get(k);
  if (hit !== null) return JSON.parse(hit);      // ヒット

  const row = await dbRead(id);                  // ミス → 自分で読む
  if (row) await redis.set(k, JSON.stringify(row), { EX: 60 });
  return row;
}

await redis.del(key(1));

let t = now(); await getAside(1); console.log('1回目(ミス):', ms(t), 'ms');
t = now();     await getAside(1); console.log('2回目(ヒット):', ms(t), 'ms');
t = now();     await getAside(1); console.log('3回目(ヒット):', ms(t), 'ms');
console.log('DBを読んだ回数:', dbReads);

await redis.quit(); await closeDb();
bash
$ node read1-aside.mjs
1回目(ミス): 32.6 ms
2回目(ヒット): 0.5 ms
3回目(ヒット): 0.4 ms
DBを読んだ回数: 1

3回読んで、データベースには1回しか行っていません。 これがキャッシュの効き目です。

そして、1回目だけ遅い。 これが cache-aside の性格です。「初回は必ず損をする」。

cache-aside が一番多く使われている理由は、単純さです。 キャッシュが落ちても、アプリは動き続けます。 redis.get が失敗したら、そのままデータベースを読めばいいだけだからです。 後で見る「消す」との相性も、この型が一番いいです。

型2: read-through — キャッシュ層が代わりに取ってくる

アプリはキャッシュにしか話しかけません。 データベースを読むのはキャッシュ層の仕事です。

~/sd-cache/read2-through.mjs:

import { redis, key, now, ms } from './cache.mjs';
import { dbRead, closeDb, dbReads } from './db.mjs';

// 「キャッシュ層」を1つ作る。アプリはこれしか触らない
function makeReadThrough({ ttl, loader }) {
  return async function get(id) {
    const k = key(id);
    const hit = await redis.get(k);
    if (hit !== null) return JSON.parse(hit);
    const row = await loader(id);                // 読み込みは層の中に閉じ込める
    if (row) await redis.set(k, JSON.stringify(row), { EX: ttl });
    return row;
  };
}

const products = makeReadThrough({ ttl: 60, loader: dbRead });

await redis.del(key(1));

// アプリ側のコードはこれだけ。DB のことを何も知らない
let t = now(); console.log(await products(1), ms(t), 'ms');
t = now();     console.log(await products(1), ms(t), 'ms');
console.log('DBを読んだ回数:', dbReads);

await redis.quit(); await closeDb();
bash
$ node read2-through.mjs
{ id: 1, name: 'ノート', stock: 100 } 32.1 ms
{ id: 1, name: 'ノート', stock: 100 } 0.4 ms
DBを読んだ回数: 1

時間は cache-aside と同じです。当然です。やっていることが同じだからです。

違うのは、アプリ側のコードから dbRead が消えたことだけです。そしてそれが read-through の全部です。

素の Redis に read-through 機能はありません。 read-through は「キャッシュ製品が自分で DB を読む」型で、Java の Caffeine や Ehcache、クラウドのキャッシュ製品にはその機能があります。 Redis には無いので、上のように自分で層を書きます。 これは負けではありません。呼ぶ側から見れば同じものです。

型3: refresh-ahead — 期限が来る前に先に更新

cache-aside と read-through には、共通の弱点があります。「期限が切れた瞬間の1人が、必ず待たされる」。

refresh-ahead は、切れる前に裏で読み直しておきます。

~/sd-cache/read3-refresh.mjs:

import { redis, key, now, ms } from './cache.mjs';
import { dbRead, closeDb, dbReads } from './db.mjs';

const TTL = 10;        // キーが消えるまで(秒)
const FRESH = 4;       // ここを過ぎたら「そろそろ古い」とみなす(秒)

async function getRefreshAhead(id) {
  const k = key(id);
  const hit = await redis.get(k);

  if (hit === null) {                              // 完全に無い → 待って読む
    const row = await dbRead(id);
    if (row) await redis.set(k, pack(row), { EX: TTL });
    return row;
  }

  const box = JSON.parse(hit);
  if (Date.now() > box.freshUntil) {
    // ⚠️ await しない。呼び出し元は待たせず、裏で入れ直す
    refresh(id).catch((e) => console.error('refresh失敗:', e.message));
  }
  return box.value;                                // 少し古いかもしれない値を即返す
}

async function refresh(id) {
  const row = await dbRead(id);
  if (row) await redis.set(key(id), pack(row), { EX: TTL });
}

function pack(row) {
  return JSON.stringify({ value: row, freshUntil: Date.now() + FRESH * 1000 });
}

const sleep = (s) => new Promise((r) => setTimeout(r, s * 1000));

await redis.del(key(1));
let t = now(); await getRefreshAhead(1); console.log('初回:', ms(t), 'ms');

await sleep(5);   // FRESH(4秒) を過ぎた。でも TTL(10秒) はまだ切れていない
t = now(); await getRefreshAhead(1); console.log('期限手前の読み:', ms(t), 'ms');

await sleep(1);   // 裏の読み直しが終わったころ
console.log('DBを読んだ回数:', dbReads);

await redis.quit(); await closeDb();
bash
$ node read3-refresh.mjs
初回: 32.4 ms
期限手前の読み: 0.5 ms
DBを読んだ回数: 2

2回目も 0.5ms です。 データベースには2回行っているのに、読んだ人は一度も待っていません。

代償は2つあります。返した値は最大4秒古いこと。そして誰も読まないキーまで読み直してしまう(データベースへの読み込みが無駄に増える)ことです。

3つの対比

cache-asideread-throughrefresh-ahead
DBを読むのはアプリキャッシュ層キャッシュ層(裏で先に)
実装の手間一番少ない。20行中。層を1つ作る一番多い。期限を2段に持つ
初回の遅さ遅い(必ず1回待つ)遅い(同じ)遅い(初回だけは同じ)
期限切れの瞬間待たされる待たされる待たされない
一貫性書き込み側次第書き込み側次第必ず少し古い(FRESH秒ぶん)
キャッシュが落ちたときDBを読んで動き続けられる層の作り次第層の作り次第
要らないDB読み込み起きない起きない起きる(誰も読まなくても更新する)
向く場面ほぼ全部読み方を1箇所に閉じたいときアクセスが集中する少数のキー

迷ったら cache-aside です。 実際、世の中のほとんどのキャッシュはこれです。 refresh-ahead は「トップページの人気ランキング」のような、キーが数個しかない場所にだけ効きます。 キーが100万個ある場所でやると、誰も読まないキーの更新でデータベースを潰します。

[スクリーンショット: 01_read-three-types.png] node read1-aside.mjs、node read2-through.mjs、node read3-refresh.mjs を続けて実行し、3つの結果が並んでいる画面を撮ってください。


③ 書き方の型を3つ、実装して比べる

ここからが本題です。 冒頭の「更新したのに古い値が返る」は、全部この節の話です。

測るのは2つです。書き込みにかかった時間と、書いた直後に読んだときの時間。この2つはトレードオフの関係にあります。

型1: write-through — 同時に書く

~/sd-cache/write1-through.mjs:

import { redis, key, now, ms } from './cache.mjs';
import { dbRead, dbWrite, closeDb } from './db.mjs';

async function getAside(id) {
  const hit = await redis.get(key(id));
  if (hit !== null) return JSON.parse(hit);
  const row = await dbRead(id);
  if (row) await redis.set(key(id), JSON.stringify(row), { EX: 60 });
  return row;
}

async function writeThrough(id, stock) {
  await dbWrite(id, stock);                                     // ①DBに書く
  const row = { id, name: 'ノート', stock };
  await redis.set(key(id), JSON.stringify(row), { EX: 60 });    // ②キャッシュも書く
}

await redis.del(key(1));

let t = now(); await writeThrough(1, 111); console.log('書き込み:', ms(t), 'ms');
t = now(); const v = await getAside(1);     console.log('直後の読み:', ms(t), 'ms', v.stock);

await redis.quit(); await closeDb();
bash
$ node write1-through.mjs
書き込み: 31.8 ms
直後の読み: 0.4 ms 111

書き込みが 31.8ms。読みは 0.4ms で、しかも新しい値です。

書き込みが遅くなっているのが、この型の代償です。 データベースの往復に、キャッシュへの書き込みが上乗せされます。しかも、キャッシュ側が失敗したらどうするかを決めないといけません。

型2: write-behind(write-back)— 後で書く

先にキャッシュへ書いて、データベースへは後でまとめて書きます。

~/sd-cache/write2-behind.mjs:

import { redis, key, now, ms } from './cache.mjs';
import { dbRead, dbWrite, closeDb } from './db.mjs';

const pending = new Map();     // まだDBに書いていないもの

async function writeBehind(id, stock) {
  const row = { id, name: 'ノート', stock };
  await redis.set(key(id), JSON.stringify(row), { EX: 60 });   // キャッシュだけ
  pending.set(id, stock);                                      // 借りを記録して、すぐ返る
}

async function flush() {
  for (const [id, stock] of pending) { await dbWrite(id, stock); pending.delete(id); }
}

await redis.del(key(1));

let t = now(); await writeBehind(1, 222); console.log('書き込み:', ms(t), 'ms');
t = now();
const hit = JSON.parse(await redis.get(key(1)));
console.log('直後の読み:', ms(t), 'ms', hit.stock);

console.log('この時点のDB:', (await dbRead(1)).stock);   // ← まだ古い
await flush();
console.log('flush後のDB:', (await dbRead(1)).stock);

await redis.quit(); await closeDb();
bash
$ node write2-behind.mjs
書き込み: 0.6 ms
直後の読み: 0.3 ms 222
この時点のDB: 111
flush後のDB: 222

書き込みが 0.6ms。50倍以上速い。 でも、その行の2つ下を見てください。

この時点のDB: 111。まだ書いていません。 速さの正体は「まだ書いていない」だけです。仕事が減ったわけではなく、後ろに送っただけです。

落ちると失います。 実際に起こします。flush() の前にプロセスを殺します。

~/sd-cache/write2-crash.mjs:

import { redis, key } from './cache.mjs';
import { dbRead, closeDb } from './db.mjs';

const row = { id: 1, name: 'ノート', stock: 999 };
await redis.set(key(1), JSON.stringify(row), { EX: 60 });
console.log('キャッシュに書いた: 999');
console.log('DBはまだ:', (await dbRead(1)).stock);

process.exit(1);          // ← ここで落ちる。flush は永遠に来ない
bash
$ node write2-crash.mjs
$ redis-cli --no-auth-warning -a "$REDIS_PASS" get sd:product:1
$ mysql -u appuser -p"$DB_PASS" -N -e "SELECT stock FROM cachedb.products WHERE id=1;"
キャッシュに書いた: 999
DBはまだ: 222
{"id":1,"name":"ノート","stock":999}
222

キャッシュは 999、データベースは 222。 そして 60 秒後、TTL でキャッシュが消えると、999 は世界からいなくなります。

在庫が消えるだけならまだしも、これが「支払い済み」フラグだったらと考えてください。write-behind を使ってよいのは、失っても謝れるデータだけです。閲覧数、いいねの数、最終アクセス時刻。注文と残高では使いません。

型3: write-around — キャッシュを飛ばして書く

~/sd-cache/write3-around.mjs:

import { redis, key, now, ms } from './cache.mjs';
import { dbRead, dbWrite, closeDb } from './db.mjs';

async function writeAround(id, stock) {
  await dbWrite(id, stock);          // DBにだけ書く。キャッシュには触らない
}

async function getAside(id) {
  const hit = await redis.get(key(id));
  if (hit !== null) return JSON.parse(hit);
  const row = await dbRead(id);
  if (row) await redis.set(key(id), JSON.stringify(row), { EX: 60 });
  return row;
}

await redis.del(key(1));
await getAside(1);                   // まずキャッシュに入れておく(古い値)

let t = now(); await writeAround(1, 333); console.log('書き込み:', ms(t), 'ms');
t = now(); const v = await getAside(1);   console.log('直後の読み:', ms(t), 'ms', '→', v.stock);

await redis.quit(); await closeDb();
bash
$ node write3-around.mjs
書き込み: 31.5 ms
直後の読み: 0.4 ms → 222

333 に書いたのに、222 が返りました。これが冒頭の症状そのものです。

write-around は、キャッシュに一切触りません。 だから古いキャッシュがそのまま残ります。 TTL が切れるまで、ずっとです。

では write-around は使えないのかというと、そうではありません。 キャッシュを空にしてから測ると、話が変わります。

bash
$ redis-cli --no-auth-warning -a "$REDIS_PASS" del sd:product:1
$ node write3-around.mjs
書き込み: 31.4 ms
直後の読み: 32.0 ms → 333

直後の読み込みが 32ms。遅い。 キャッシュに何も入れていないので、読む人が待たされます。

write-around が向くのは、「書いたきり、しばらく読まれないデータ」です。ログ、監査記録、一括取り込み。書いた端からキャッシュに入れると、読まれないデータでキャッシュが埋まるので、あえて飛ばします。

3つの実測を表にする

WAN_MS=30(データベースまで片道 30ms)での実測です。

write-throughwrite-behindwrite-around
書き込み時間31.8 ms0.6 ms31.5 ms
直後の読み(キャッシュ有)0.4 ms(新しい値)0.3 ms(新しい値)0.4 ms(古い値)
直後の読み(キャッシュ空)0.4 ms0.3 ms32.0 ms
落ちたら失わない失う失わない
DBとキャッシュのズレほぼ無い書くまでズレるTTLまでズレ続ける
キャッシュが汚れるか書いたもの全部が乗る全部が乗る乗らない
向く場面書いた直後に読まれる失ってよい・書き込みが多い書いたきり読まれない

数字は自分の環境で必ず変わります。 WAN_MS を変えて測り直してください。

bash
$ WAN_MS=100 node write1-through.mjs
$ WAN_MS=100 node write2-behind.mjs

WAN_MS が大きいほど、write-behind の速さが際立ちます。 そして失う量も増えます。

[スクリーンショット: 02_write-three-types.png] node write1-through.mjs、node write2-behind.mjs、node write3-around.mjs を続けて実行し、書き込み時間の差が並んでいる画面を撮ってください。


④ 「消す」か「書き換える」か

write-through には、書き方が2つあります。

  • 書き換える(update): redis.set(key, 新しい値)
  • 消す(delete): redis.del(key) して、次の読み込みで入れ直させる

直感的には「書き換える」ほうが良さそうに見えます。 次の読み込みが速いからです。しかし、実際には「消す」が定番です。 理由を、動かして確かめます。

書き換えると競合する

2つの更新が同時に走ったときに何が起きるかを、わざと再現します。

~/sd-cache/race-update.mjs:

import { redis, key } from './cache.mjs';
import { dbRead, dbWrite, closeDb } from './db.mjs';

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

// ①DBに書く → ②キャッシュを書き換える。②までの間に隙間がある
async function updateAndSet(id, stock, gapMs, label) {
  await dbWrite(id, stock);
  console.log(`${label}: DBに ${stock} を書いた`);
  await sleep(gapMs);                       // GC・再送・スレッド切替で実際に起きる隙間
  await redis.set(key(id), JSON.stringify({ id, name: 'ノート', stock }), { EX: 60 });
  console.log(`${label}: キャッシュに ${stock} を書いた`);
}

await redis.del(key(1));

await Promise.all([
  updateAndSet(1, 100, 120, 'A'),                              // Aは隙間が長い
  (async () => { await sleep(40); await updateAndSet(1, 200, 0, 'B'); })(),
]);

console.log('---');
console.log('DB       :', (await dbRead(1)).stock);
console.log('キャッシュ:', JSON.parse(await redis.get(key(1))).stock);

await redis.quit(); await closeDb();
bash
$ node race-update.mjs
A: DBに 100 を書いた
B: DBに 200 を書いた
B: キャッシュに 200 を書いた
A: キャッシュに 100 を書いた
---
DB       : 200
キャッシュ: 100

データベースは 200、キャッシュは 100。 A も B も、自分の仕事は正しくやっています。 A は DB に書いてキャッシュに書いた。B も同じです。 なのに、順番が交錯しただけで、キャッシュに「誰も最後に決めていない値」が残りました。

そしてこれは、TTL の 60 秒が来るまで直りません。 誰も気づきません。エラーも警告も1行も出ません。

これが冒頭の「更新したのに古い値が返る」の、もう1つの正体です。片方の書き込みが遅れただけで起きます。

消すほうが安全

同じ交錯を、del に変えて再現します。

~/sd-cache/race-delete.mjs:

import { redis, key } from './cache.mjs';
import { dbRead, dbWrite, closeDb } from './db.mjs';

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function updateAndDel(id, stock, gapMs, label) {
  await dbWrite(id, stock);
  console.log(`${label}: DBに ${stock} を書いた`);
  await sleep(gapMs);
  await redis.del(key(id));                 // ← 書き換えず、消すだけ
  console.log(`${label}: キャッシュを消した`);
}

async function getAside(id) {
  const hit = await redis.get(key(id));
  if (hit !== null) return JSON.parse(hit);
  const row = await dbRead(id);
  if (row) await redis.set(key(id), JSON.stringify(row), { EX: 60 });
  return row;
}

await redis.del(key(1));

await Promise.all([
  updateAndDel(1, 100, 120, 'A'),
  (async () => { await sleep(40); await updateAndDel(1, 200, 0, 'B'); })(),
]);

console.log('---');
console.log('DB          :', (await dbRead(1)).stock);
console.log('次の読み込み :', (await getAside(1)).stock);

await redis.quit(); await closeDb();
bash
$ node race-delete.mjs
A: DBに 100 を書いた
B: DBに 200 を書いた
B: キャッシュを消した
A: キャッシュを消した
---
DB          : 200
次の読み込み : 200

同じ交錯なのに、結果が合っています。

理由は単純です。「消す」に順番は無いからです。

書き換えは「私の持っている値が正しい」と主張する操作です。遅れて届いた主張が、新しい主張を上書きします。 削除は「私はもう正しい値を知らない」と言う操作です。何回、どんな順番で言っても、結論は「キャッシュは空」で同じです。 これが cache-aside + 削除 が定番になっている理由です。

書き換える(set)消す(del)
交錯したとき古い値が残る(順番に依存する)必ず空になる(順番に依存しない)
次の読み込み速い(既に入っている)1回だけ遅い(入れ直す)
書く側が持つべき情報完成した値の全部(他の列も含めて)キーだけ
書き込み経路が複数あるとき全部の経路が正しい値を作れないといけないどの経路も del するだけ
失敗したとき古い値が残り続けるキャッシュが空になるだけ(安全側に倒れる)

特に4行目が効きます。 在庫を更新する場所が、API・管理画面・バッチの3つあったとします。書き換え方式だと、3箇所すべてが「キャッシュに入れるべき完成品」を組み立てられないといけません。 1箇所が name を入れ忘れたら、そこから壊れます。削除方式なら、3箇所とも redis.del(key) の1行で終わりです。

消しても残る競合が、1つだけある

正直に書きます。del にしても、まだ1つ穴があります。

  1. 読み手 R がキャッシュミスして、データベースから 100 を読む(まだキャッシュには入れていない)
  2. 書き手 W がデータベースに 200 を書き、キャッシュを del する(消すものが無い)
  3. R が、手元に持っていた 100 をキャッシュに入れる

結果、キャッシュに 100 が残ります。 R が読んでから入れるまでの隙間に、W が丸ごと入ってしまった形です。

対処は、完璧を目指さないことです。

  • TTL を短くする(数分で自然に直る。これが実質の答え)
  • 入れるときの TTL をさらに短くする(SET key value EX 30 NX のように、読みで入れた値だけ寿命を縮める)
  • 少し待ってからもう一度消す(更新の 500ms 後に del をもう1回。二重削除)

キャッシュの一貫性は「必ず正しい」にはできません。 できるのは「ズレる窓を短くする」ことだけです。書いた直後に読むと無い — レプリケーションとCAPで見た結果整合と、まったく同じ話をしています。 キャッシュは、レプリカの一種です。 置き場所がメモリで、寿命が短いだけです。

[スクリーンショット: 03_race-update-vs-delete.png] node race-update.mjs と node race-delete.mjs を続けて実行し、キャッシュの値が食い違う側と合う側が並んでいる画面を撮ってください。


⑤ 期限の付け方

TTL を付けないとどうなるか

まず、いま Redis がどういう設定で動いているかを見ます。

bash
$ redis-cli --no-auth-warning -a "$REDIS_PASS" config get maxmemory
$ redis-cli --no-auth-warning -a "$REDIS_PASS" config get maxmemory-policy
1) "maxmemory"
2) "0"
1) "maxmemory-policy"
2) "noeviction"

この2行が、素の Redis の既定です。そして両方とも危険側です。

  • maxmemory 0 は「上限なし」。メモリが尽きるまで増え続けます
  • noeviction は「いっぱいになっても何も消さない」。代わりに書き込みがエラーになります

つまり既定の Redis は、「メモリが尽きるまで太って、尽きたら書き込みを全部断る」設定です。

TTL 無しでキーを積むと、何が起きるか見ます。

~/sd-cache/ttl-none.mjs:

import { redis } from './cache.mjs';

const N = 200000;
const pipe = redis.multi();
for (let i = 0; i < N; i++) {
  pipe.set(`sd:notll:${i}`, 'x'.repeat(200));    // ← TTLを付けていない
  if (i % 5000 === 4999) { await pipe.exec(); }
}
await pipe.exec();

console.log('キー数:', await redis.dbSize());
await redis.quit();
bash
$ node ttl-none.mjs
$ redis-cli --no-auth-warning -a "$REDIS_PASS" info memory | grep human
キー数: 200003
used_memory_human:63.42M
used_memory_peak_human:63.44M

63MB。20万件の、200 バイトの値だけでこれです。

そして、待っても減りません。

bash
$ redis-cli --no-auth-warning -a "$REDIS_PASS" ttl sd:notll:100
(integer) -1

-1 は「期限が設定されていない」という意味です(-2 は「キーが存在しない」)。このキーは、誰かが消すまで永遠に残ります。

TTL を付け忘れたキャッシュは、キャッシュではありません。 ただのデータベースです。 しかも、電源を切ると消える、上限のないデータベースです。一番たちが悪い。

上限を付けて、追い出しを見る

上限を付けます。この設定は後で必ず戻します。

bash
$ redis-cli --no-auth-warning -a "$REDIS_PASS" config set maxmemory 32mb
$ redis-cli --no-auth-warning -a "$REDIS_PASS" config set maxmemory-policy allkeys-lru
$ redis-cli --no-auth-warning -a "$REDIS_PASS" info stats | grep evicted
$ redis-cli --no-auth-warning -a "$REDIS_PASS" dbsize
evicted_keys:96214
(integer) 103789

9万件が、その場で追い出されました。 63MB あったものを 32MB に収めるためです。

ここで noeviction に戻して、同じことをやると挙動が変わります。

bash
$ redis-cli --no-auth-warning -a "$REDIS_PASS" config set maxmemory-policy noeviction
$ node ttl-none.mjs
OOM command not allowed when used memory > 'maxmemory'.

エラーで止まりました。 noeviction は「消すくらいなら書けないほうがマシ」という設定です。

キャッシュとして使うなら、これは間違いです。 キャッシュは消えていいものだからです。逆に、セッションやキューとして使っているなら noeviction が正しいです。勝手に消えたら困るからです。

LRU / LFU / TTL の違い

追い出す相手の選び方は、大きく3つの考え方があります。

方針誰を追い出すか向く場面
noeviction誰も追い出さない(書き込みがエラーになる)消えたら困るデータ。セッション・キュー
allkeys-lru最後に使われたのが一番古いキー迷ったらこれ。一般的なキャッシュ
allkeys-lfu使われた回数が一番少ないキー人気の差が大きいとき。一度だけ大量に読まれたものに居座られない
allkeys-randomでたらめ全部が同じくらい読まれるとき(ほぼ無い)
volatile-lruTTL が付いているキーの中で LRU同じ Redis にキャッシュと永続データを同居させているとき
volatile-ttl残り寿命が一番短いキー寿命に意味があるとき
volatile-randomTTL 付きの中からでたらめほぼ使わない

allkeys- と volatile- の違いが一番大事です。

  • allkeys- は全部のキーが追い出し対象。TTL の無いキーも消えます
  • volatile- はTTL が付いたキーだけが対象。TTL の無いキーは絶対に消えません

volatile-lru にしていて、全キーに TTL を付け忘れると、追い出す相手がいなくなります。 そのとき Redis は noeviction と同じ動きをします(OOM command not allowed)。「上限も方針も設定したのに落ちた」の典型です。

LRU と LFU の違いは、こういう場面で出ます。 深夜のバッチが全商品を1回ずつ読むと、LRU では「たった今読んだ」商品が全部新しい扱いになり、昼間の人気商品を押し出します。 LFU は回数で見るので、1回しか読まれていないバッチのぶんが先に追い出されます。

TTL をばらつかせる

最後の落とし穴です。全部同じ TTL にすると、同時に切れます。

~/sd-cache/ttl-same.mjs:

import { redis } from './cache.mjs';

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const pipe = redis.multi();
for (let i = 0; i < 1000; i++) pipe.set(`sd:same:${i}`, 'v', { EX: 5 });   // 全部 5 秒
await pipe.exec();

for (let s = 0; s <= 7; s++) {
  const keys = await redis.keys('sd:same:*');
  console.log(`${s}秒後: 残り ${keys.length} 件`);
  await sleep(1000);
}
await redis.quit();
bash
$ node ttl-same.mjs
0秒後: 残り 1000 件
1秒後: 残り 1000 件
2秒後: 残り 1000 件
3秒後: 残り 1000 件
4秒後: 残り 1000 件
5秒後: 残り 0 件
6秒後: 残り 0 件
7秒後: 残り 0 件

1000 件が、同じ 1 秒の中で全部消えました。

この瞬間、1000 件ぶんの読み込みが、全部データベースへ抜けます。 これがキャッシュスタンピードです。キャッシュを入れたのに、5 秒おきにデータベースが跳ねるという状態になります。

直し方は、期限をばらつかせるだけです。

// 悪い: 全員 60 秒
await redis.set(k, v, { EX: 60 });

// 良い: 60 秒 ± 15 秒 の範囲でばらつかせる
const jitter = 60 + Math.floor(Math.random() * 31) - 15;
await redis.set(k, v, { EX: jitter });

~/sd-cache/ttl-jitter.mjs に、上の EX: 5 を EX: 3 + Math.floor(Math.random() * 5) に変えたものを作って動かします。

bash
$ node ttl-jitter.mjs
0秒後: 残り 1000 件
1秒後: 残り 1000 件
2秒後: 残り 1000 件
3秒後: 残り 794 件
4秒後: 残り 605 件
5秒後: 残り 396 件
6秒後: 残り 202 件
7秒後: 残り 0 件

同じ 1000 件が、5 秒かけて散らばって消えました。 データベースへの負荷が 1/5 になったということです。

redis.keys('sd:same:*') を本番で使ってはいけません。 KEYS は全キーを走査する間、Redis 全体を止めます。 20万件あるサーバーで打つと、その間すべての応答が止まります。 本番で探すときは SCAN です。この記事では、学習用の VM で件数を数えるためだけに使っています。

[スクリーンショット: 04_ttl-jitter.png] node ttl-same.mjs と node ttl-jitter.mjs を続けて実行し、一気に 0 になる側と、少しずつ減る側が並んでいる画面を撮ってください。


⑥ キャッシュキーの設計

ここまで sd:product:1 という形を使ってきました。この形には理由があります。

何で引くか

キーは「この結果を一意に決めるものを、全部つなげたもの」です。 1つでも抜けると事故ります。

良い形何を入れているか
sd:product:1種類 : ID
sd:v2:product:1種類のバージョンを混ぜた形
sd:user:42:cart誰のを混ぜた形
sd:products:page=3:sort=price:lang=ja一覧の条件を全部混ぜた形

接頭辞(sd: や product:)を付ける理由は3つあります。

  1. 後片づけができる(sd:* だけ消せる)
  2. SCAN で種類ごとに数えられる
  3. 他の用途とぶつからない(セッションの 1 と商品の 1 が同じキーになる事故を防ぐ)

バージョンを混ぜる

キャッシュしている値の「形」を変えたとき、古い形のデータが残っていると落ちます。

たとえば { id, name, stock } を返していたものに price を足したとします。アプリを新しくしても、キャッシュには古い形が残っています。 row.price が undefined になって、画面が崩れます。

キーにバージョンを混ぜておけば、この問題は「起きなくなる」のではなく「一瞬で解決する」ようになります。

const KEY_VERSION = 'v2';                                  // 形を変えたら上げる
export const key = (id) => `sd:${KEY_VERSION}:product:${id}`;

v1 を v2 に変えた瞬間、全部がキャッシュミスになります。 データベースが1回だけ跳ねますが、古い形は1件も読まれなくなります。 v1: のキーは TTL で勝手に消えます。

これは「キャッシュを消す」より安全です。 del は消し漏れます(探し方を間違える、途中で失敗する)。バージョンを上げるのは、探さずに全部を無効にする方法です。

キーに個人を混ぜ忘れると、他人のデータが出る

キャッシュの事故の中で、一番まずいのがこれです。実際に起こします。

~/sd-cache/key-leak.mjs:

import { redis } from './cache.mjs';

// ⚠️ 悪い例: ユーザーIDが入っていない
const badKey = () => 'sd:cart';

async function getCartBad(userId) {
  const hit = await redis.get(badKey());
  if (hit !== null) return JSON.parse(hit);
  const cart = { userId, items: [`${userId}さんの商品`] };   // 本来はDBから
  await redis.set(badKey(), JSON.stringify(cart), { EX: 60 });
  return cart;
}

await redis.del(badKey());
console.log('42番が見たカート:', await getCartBad(42));
console.log('99番が見たカート:', await getCartBad(99));   // ← 別人がアクセス

await redis.quit();
bash
$ node key-leak.mjs
42番が見たカート: { userId: 42, items: [ '42さんの商品' ] }
99番が見たカート: { userId: 42, items: [ '42さんの商品' ] }

99 番のユーザーに、42 番のカートが表示されました。

エラーは1つも出ていません。テストも通ります。 開発中は自分1人でしか触らないので、絶対に気づきません。

直し方は、キーにユーザーIDを入れるだけです。

const goodKey = (userId) => `sd:user:${userId}:cart`;
bash
$ node key-leak-fixed.mjs
42番が見たカート: { userId: 42, items: [ '42さんの商品' ] }
99番が見たカート: { userId: 99, items: [ '99さんの商品' ] }

同じ事故は、ユーザーID以外でも起きます。

  • 言語を混ぜ忘れる → 日本語の人に英語のページが出る
  • 権限を混ぜ忘れる → 一般利用者に管理者向けの一覧が出る
  • 通貨・地域を混ぜ忘れる → 円の値段がドルで出る

判断の基準は1つです。「返す中身が変わる条件は、全部キーに入っているか」。 入れ忘れは、機能の不具合ではなく情報漏えいになります。安全にはできない、被害を小さくする — セキュリティ点検で見た「まず被害の大きい順に見る」なら、キャッシュキーは上から数えたほうが早い場所です。


⑦ どれを選ぶか — 判断表

ここまでの6つを、選ぶ側から並べ直します。

状況読み方書き方無効化TTL
読みが圧倒的に多い(商品ページ、記事)cache-asidewrite-through削除数分〜1時間+ジッター
書きが多く、失ってよい(閲覧数、いいね、最終アクセス)cache-asidewrite-behind不要(自分が持っている)短め
書きが多く、失ってはいけない(注文、残高、在庫)cache-asidewrite-through削除短め(数十秒)
書いたきり、しばらく読まれない(ログ、監査、一括取り込み)cache-asidewrite-around不要—
少数のキーに集中する(トップページ、ランキング)refresh-aheadwrite-through削除TTL と更新開始を2段に
計算が重く、少し古くてよい(集計、レポート)cache-asidewrite-around不要(TTLに任せる)長め(数十分)
正しさが最優先で、遅さは許せるキャッシュしない———

最後の行が一番大事です。

キャッシュを入れないという選択肢を、必ず表に残してください。 まず何から考えるかで見たとおり、設計は「入れるもの」より「入れないと決めたもの」で決まります。 キャッシュは、正しさを少し売って速さを買う取引です。売れないものを持っているときは、買えません。

そして、迷ったときの既定はこれです。

cache-aside + write-through + 削除 + TTL 5分 ± 1分

これで足りなくなってから、初めて他の型を検討します。 最初から write-behind を選ぶ理由は、ほとんどありません。


つまずいたところ

1. read-through を Redis の設定で探して、1時間溶かした

「read-through 有効化」のような設定を、redis.conf の中でずっと探していました。 ありません。Redis はキーバリューストアであって、データベースの読み方を知らないからです。

read-through は「アプリの中に層を1つ作る」ことでしか実現しません。 これに気づくまで、公式ドキュメントを読む場所が間違っていました。

2. write-behind の実験で Ctrl+C したら、本当に在庫が消えた

「失う」を頭では分かっていたつもりでした。 実際に flush() の前に Ctrl+C を押して、SELECT stock が古い値のままなのを見たときに、初めて怖くなりました。

そのあと pending の中身を JSON でファイルに落とすようにして、再起動時に読み直すという「ちゃんとした write-behind」を書きかけて、やめました。それを真面目にやると、結局データベースをもう1つ作ることになるからです。write-behind が難しいのは、書くこと自体ではなく、落ちたあとを引き受けることでした。

3. config set した設定が、再起動で消えた

maxmemory 32mb を設定して実験し、VM を再起動したら 0 に戻っていました。

CONFIG SET はメモリ上の設定を変えるだけで、ファイルには書きません。 残したい場合は CONFIG REWRITE を打つか、/etc/redis/redis.conf を編集して再起動します。

この記事の実験では、消えてくれたほうが安全なので CONFIG SET だけにしています。 ただし「戻し忘れても再起動で戻る」に頼らないでください。 学習用の VM は、何ヶ月も再起動しないことがあります。

4. JSON.parse が落ちた

redis.get は、キーが無いとき null を返します。JSON.parse(null) は例外ではなく null を返してしまうので、その先で row.stock が TypeError になって初めて気づきます。

if (hit !== null) と、必ず null そのものと比べてください。 if (hit) にすると、空文字 "" を保存したときにミス扱いになります。

5. 「消す」に変えたのに、まだ古い値が出た

race-delete.mjs を書いた直後、別の場所に redis.set が1つ残っていました。 更新経路が2つあって、片方だけ直していたためです。

削除方式に変えるときは、redis.set を全部探して、書き込み経路が本当に全部 del になっているかを確認してください。

bash
$ grep -rn "redis.set" ~/sd-cache/*.mjs

「1箇所でも書き換えが残っていると、削除方式の利点は全部消えます。」


後片づけ

この節は必ずやってください。 特に maxmemory は、放置すると別の用途のキーが黙って消えます。

1. Redis の設定を戻す

bash
$ redis-cli --no-auth-warning -a "$REDIS_PASS" config set maxmemory 0
$ redis-cli --no-auth-warning -a "$REDIS_PASS" config set maxmemory-policy noeviction
$ redis-cli --no-auth-warning -a "$REDIS_PASS" config get maxmemory
$ redis-cli --no-auth-warning -a "$REDIS_PASS" config get maxmemory-policy
1) "maxmemory"
2) "0"
1) "maxmemory-policy"
2) "noeviction"

両方が元の値に戻っていることを、目で確認してください。

2. この記事で作ったキーだけ消す

FLUSHALL は打ちません。 sd: で始まるものだけを消します。

bash
$ redis-cli --no-auth-warning -a "$REDIS_PASS" --scan --pattern 'sd:*' | xargs -r -n 500 redis-cli --no-auth-warning -a "$REDIS_PASS" del
$ redis-cli --no-auth-warning -a "$REDIS_PASS" --scan --pattern 'sd:*' | wc -l
0

--scan は KEYS と違って、少しずつ取ってくるので Redis を止めません。 -n 500 は「500 個ずつ del に渡す」という意味で、引数が長すぎて失敗するのを防ぎます。

3. メモリが戻ったか見る

bash
$ redis-cli --no-auth-warning -a "$REDIS_PASS" info memory | grep used_memory_human
$ redis-cli --no-auth-warning -a "$REDIS_PASS" dbsize
used_memory_human:1.05M
(integer) 0

4. データベースと作業ディレクトリを消す

bash
$ mysql -u appuser -p -e "DROP DATABASE cachedb;"
$ rm -rf ~/sd-cache

環境変数も落としておきます。

bash
$ unset DB_PASS REDIS_PASS

[スクリーンショット: 05_cleanup-confirm.png] 後片づけ後に config get maxmemory、config get maxmemory-policy、dbsize を実行し、0 / noeviction / 0 が並んでいる画面を撮ってください。


まとめ — 理解できたこと

  • 「更新したのに古い値が返る」の原因は、読み側ではなく書き側にある。 読み方をいくら変えても直らない
  • キャッシュの設計は4つ決めるだけ。 読むとき誰がDBを見るか / 書くときいつDBに書くか / 書き換えるか消すか / いつ消えるか
  • cache-aside・read-through・refresh-ahead の違いは「誰がDBを読むか」だけ。 時間はほぼ同じ(実測でも 32ms と 32ms)
  • cache-aside を既定にする。 キャッシュが落ちてもアプリが動き続けるのは、この型だけ
  • 素の Redis に read-through 機能は無い。 アプリの中に層を作るしかない。呼ぶ側から見れば同じもの
  • refresh-ahead は「必ず少し古い値」を返す型。 キーが数個の場所にだけ効く。キーが多い場所でやるとDBを潰す
  • write-behind が速い理由は「まだ書いていない」から。 仕事は減っていない。後ろに送っただけ
  • write-behind は落ちると失う。 実測で書き込み 0.6ms は魅力的だが、失って謝れるデータにしか使えない
  • write-around はキャッシュに触らないので、古い値がTTLまで残り続ける。 書いたきり読まれないデータ専用
  • 書き換え(set)は交錯すると古い値が残る。 A と B がそれぞれ正しく動いても、順番が入れ替わるだけで壊れる
  • 削除(del)に順番は無い。 何回、どんな順で呼んでも結論は「空」で同じ。だから cache-aside + 削除 が定番
  • 削除方式でも、読みと書きが交錯する穴は残る。 完璧にはできない。TTLでズレる窓を短くするだけ
  • キャッシュはレプリカの一種。 結果整合の話と、まったく同じ構造をしている
  • TTL の無いキーは TTL コマンドで -1 を返す。 -1 のキャッシュは、電源で消える上限なしのデータベース
  • 素の Redis の既定は maxmemory 0 と noeviction。 メモリが尽きるまで太り、尽きたら書き込みを全部断る
  • allkeys- は TTL 無しのキーも消す。volatile- は TTL 付きしか消さない。 volatile- で TTL を付け忘れると、上限を設定したのに OOM で落ちる
  • LRU は「最後に使った時刻」、LFU は「使われた回数」。 夜のバッチが全件を1回読む環境では LFU が効く
  • 全部同じ TTL にすると同じ1秒で全部消える。 1000件が一斉にDBへ抜ける。± 数割 でばらつかせるだけで防げる
  • 本番で KEYS を打たない。 走査中は Redis 全体が止まる。探すなら SCAN
  • キーは「返す中身が変わる条件を全部つなげたもの」。 1つ抜けると、その条件で結果が混ざる
  • キーに誰のかを入れ忘れると、他人のデータが表示される。 エラーも出ず、1人で開発している限り絶対に気づかない
  • 形を変えたらキーのバージョンを上げる。 消し漏れる del より、探さずに全部無効化できるほうが安全
  • 迷ったら cache-aside + write-through + 削除 + TTL 5分±1分。 足りなくなってから他の型を考える
  • そして、キャッシュを入れないという選択肢を必ず表に残す。 正しさを売れないものは、速さを買えない

参考リンク


次に読む

この記事は 【深掘り】システム設計 の 5 / 17 本目です。

記事
← 前の記事キャッシュを置く5つの層 — 入れたのに速くならない
→ 次の記事CDNとエッジキャッシュ — 距離は速度で解決できない

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

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

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

System Design›System Design — Cache Strategies
  • cache-aside / read-through / refresh-ahead
  • write-through / write-behind / write-around

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

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

コメント

コメントする

目次