ਕੈਸ਼ ਸਟੈਮਪੀਡ ਕੀ ਹੁੰਦਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇਸ ਨੂੰ ਕਿਵੇਂ ਰੋਕਦੇ ਹੋ?

Question

Accepted Answer

A **cache stampede** (ਜਾਂ dogpile) ਉਦੋਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇੱਕ hot ਕੈਸ਼ ਕੀ expire ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ **ਬਹੁਤ ਸਾਰੀਆਂ ਸਮਕਾਲੀ ਬੇਨਤੀਆਂ ਇੱਕ ਸਾਥ ਉਸ ਨੂੰ ਮਿਸ ਕਰਦੀਆਂ ਹਨ**, ਸਭ ਇੱਕ ਹੀ ਮੁੱਲ ਨੂੰ ਦੁਬਾਰਾ ਜਾਂਚ ਕਰਨ ਲਈ ਉਤਸ ਤੱਕ ਡਿੱਗ ਜਾਂਦੀਆਂ ਹਨ। Origin (DB ਜਾਂ ਸੇਵਾ) ਨੂੰ ਇੱਕ ਫਟੇ ਨਾਲ ਸ਼ੱਕਤੀ ਨਾਲ ਮਾਰਿਆ ਜਾਂਦਾ ਹੈ ਜੋ ਇਹ ਸੰਭਾਲ ਨਹੀਂ ਸਕਦਾ, ਕਦੀ-ਕਦੀ ਸਿਸਟਮ ਨੂੰ ਡਾਊਨ ਕਰ ਦਿੰਦਾ ਹੈ।

## ਕਾਰਨ

```text
t=0   hot key expires
t=0+  1000 requests arrive → all miss → all query the DB for the SAME value
      → DB overwhelmed; latency spikes; failures cascade
```

Trigger **ਇੱਕ popular key ਦੀ ਸਮਕਾਲੀ expiry** ਹੈ। Fix ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੈ ਕਿ ਸਿਰਫ ਇੱਕ (ਜਾਂ ਕੁਝ) recomputation ਹੁੰਦੀ ਹੈ, ਜਾਂ ਬੇਨਤੀਆਂ ਸਭ ਇੱਕ ਸਾਥ expire ਨਹੀਂ ਹੁੰਦੀਆਂ।

## Fixes

- **Locking / single-flight** — ਪਹਿਲੀ miss ਇੱਕ lock ਲੈਂਦੀ ਹੈ ਅਤੇ recompute ਕਰਦੀ ਹੈ; ਹਰ ਕੋਈ ਹੋਰ ਉਸ ਇੱਕ ਨਤੀਜੇ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ ਬਜਾਏ ਸਭਾ origin ਨੂੰ hit ਕਰਨ ਦੇ।
- **Stale-while-revalidate** — ਥੋੜੀ stale ਮੁੱਲ ਤੁਰੰਤ ਪੇਸ਼ ਕਰੋ ਜਦੋਂ ਕਿ ਇੱਕ background ਕਾਰਜ ਇਸ ਨੂੰ refresh ਕਰੇ। ਕੋਈ ਵੀ ਬੇਨਤੀ origin 'ਤੇ block ਨਹੀਂ ਕਰਦੀ।
- **Early / probabilistic recomputation** — ਇੱਕ key ਨੂੰ expiry ਤੋਂ *ਪਹਿਲਾਂ* refresh ਕਰੋ, ਇੱਕ probability ਦੇ ਨਾਲ ਜੋ expiry ਦੇ ਨਿਕਤ ਅਪਧੋ, ਇਸ ਲਈ ਇੱਕ ਸ਼ਾਨਦਾਰ ਬੇਨਤੀ stampede ਤੋਂ ਪਹਿਲਾਂ ਇਸ ਨੂੰ ਰਾਖੀ ਕਰਦਾ ਹੈ।
- **Jittered TTLs** — TTLs ਵਿੱਚ randomness ਸ਼ਾਮਲ ਕਰੋ ਇਸ ਲਈ keys ਸਭ ਇੱਕ ਹੀ ਝੜਪ ਵਿੱਚ expire ਨਹੀਂ ਕਰਦੀਆਂ।
- **Request coalescing** — identical ਸਮਕਾਲੀ ਬੇਨਤੀਆਂ ਨੂੰ ਇੱਕ origin ਕਾਲ ਵਿੱਚ ਸਮੂਹ ਕਰੋ।

## Single-flight pseudo-code

```text
function get(key):
  val = cache.get(key)
  if val is present: return val            // fast path: a hit

if lock.acquire(key, ttl=5s):            // only ONE request wins the lock
    try:
      val = recompute()                    // hit the origin exactly once
      cache.set(key, val, ttl)
    finally:
      lock.release(key)
    return val
  else:
    wait_briefly(); return get(key)        // others wait, then read the filled cache
```

Lock ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਬਿਲਕੁਲ ਇੱਕ origin ਕਾਲ ਹੁੰਦਾ ਹੈ; ਹਰ ਹੋਰ ਸਮਕਾਲੀ ਬੇਨਤੀ ਉਡੀਕ ਕਰਦੀ ਹੈ ਅਤੇ ਫਿਰ freshly ਕੈਸ਼ ਕੀਤੇ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਦੀ ਹੈ।

## ਇਹ ਕੀ ਮਾਇਨੇ ਰਖਦਾ ਹੈ

Ek stampede ਇੱਕ routine cache expiry ਨੂੰ ਇੱਕ outage ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ: ਕੈਸ਼ ਜੋ ਤੁਹਾਡੇ DB ਨੂੰ protect ਕਰ ਰਿਹਾ ਸੀ ਅਚਾਨਕ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਪੂਰਬ traffic ਇੱਕ ਸਾਥ origin 'ਤੇ ਆ ਜਾਂਦਾ ਹੈ। ਕਾਰਨ (hot keys ਦੀ ਸਮਕਾਲੀ expiry) ਅਤੇ fixes (single-flight, stale-while-revalidate, jitter) ਨੂੰ ਜਾਣਨਾ real load ਦੇ ਤਹਿਤ caches ਨੂੰ reliable ਰੱਖਣ ਲਈ ਜਰੂਰੀ ਹੈ।