# فصل ۰۴ — کارِ دسته‌ای و صف

<div dir="rtl">

# فصل ۰۴ — کارِ دسته‌ای و صف

## در این فصل چه یاد می‌گیری

۲۰۰ کار را به یک صف می‌دهیم و سرویسِ پایین‌دستی سی درصدِ مواقع جواب نمی‌دهد. **بدونِ تلاشِ دوباره ۵۷ کار می‌میرد؛ با حداکثر سه تلاش، ۶ تا.**

بعد قیمتش را می‌بینیم: همان تلاشِ دوباره برای ۲۰۰ کار **۲۷۳ ردیف** در پایگاه داده می‌نویسد. یک ستونِ کلیدِ اصلی اضافه می‌کنیم و عدد دقیقاً **۲۰۰** می‌شود — بدونِ اینکه حتی یک تلاش کم شود.

و اول از همه **ساعتِ مجازی** را می‌نویسیم: بیست خط کد که باعث می‌شود آزمایشی با ۲۸ ثانیه انتظار، در صفر ثانیه و با همان عددها اجرا شود. **تا آخرِ ترم همراهمان است.**

![ماشینی که کارت‌های نپذیرفته را به یک ریلِ کناری می‌فرستد](/lesson-assets/t4-s04-batch-and-queue/prompt/01-image-retry-siding.png)

آخر این فصل می‌توانی:

- ساعتِ مجازی بنویسی و رفتارِ زمان‌دار را قطعی و تکرارپذیر آزمایش کنی
- صفی با تلاشِ دوباره و صفِ نامه‌های مرده بسازی
- کارِ یکسان‌توان را از غیریکسان‌توان تشخیص بدهی و **با شمارش** ثابتش کنی
- بگویی عقب‌نشینیِ نمایی و `jitter` دقیقاً چه چیزی را می‌خرند

## قبل از شروع

**از فصلِ ۲:** مهلتِ زمانی و اینکه سرور بعد از رفتنِ کلاینت هم کار را تمام می‌کند. همان‌جا دیدیم بعضی کارها در قالبِ «درخواست و پاسخ» جا نمی‌شوند.

**از ترمِ ۲ فصلِ ۱:** «هم‌توانی» را آنجا برای مسیرِ داده دیدی: اجرای دوباره نباید وضعیت را عوض کند. **اینجا همان ایده به یک کارِ تکی می‌رسد و اسمش «یکسان‌توانی» است** — و این بار کسی که اجرای دوباره را راه می‌اندازد خودِ سامانه است، نه تو.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-4-deployment/session-04-batch-and-queue.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

| اجرا | زمانِ تقریبی |
|---|---|
| کلِ نوت‌بوک روی CPU | حدودِ یک دقیقه |
| GPU | لازم نیست |

<div dir="rtl">

## ۱. ساعتِ مجازی

از این فصل به بعد مرتب با زمان کار داریم: مهلتِ تلاشِ دوباره، عمرِ `cache`، پنجرهٔ انتشار، مهلتِ قطع‌کنندهٔ مدار. اگر این‌ها را با `time.sleep` امتحان کنیم، دو چیزِ بد اتفاق می‌افتد: **آزمایش کند می‌شود، و نتیجه‌اش به سرعتِ ماشین بستگی پیدا می‌کند.**

راهِ حل ساده است: **زمان را از سیستم نخوان، خودت نگهش دار.**

</div>

```python
class Clock:
    """ساعتی که خودت جلو می‌بری. زمانِ سیستم را نمی‌خواند، پس نتیجه‌اش تکرارپذیر است."""

    def __init__(self, start=0.0):
        self.t = float(start)

    def now(self):
        return self.t

    def advance(self, seconds):
        self.t += seconds
        return self.t

    def jump_to(self, moment):
        self.t = max(self.t, moment)         # ساعت هرگز عقب نمی‌رود
        return self.t


clock = Clock()
deadline = clock.now() + 300
print("الان         :", clock.now())
print("منقضی شده؟   :", clock.now() > deadline)
clock.advance(301)
print("بعد از ۳۰۱ ثانیه:", clock.now(), "· منقضی شده؟", clock.now() > deadline)
```

```text
الان         : 0.0
منقضی شده؟   : False
بعد از ۳۰۱ ثانیه: 301.0 · منقضی شده؟ True
```

<div dir="rtl">

**پنج دقیقه گذشت و صفر ثانیه صبر کردیم.**

و مهم‌تر از سرعت: نتیجه **قطعی** است. در ژرفا ترمِ ۶ فصلِ ۶ یک عدد بود که هر بار فرق می‌کرد و همان‌جا صادقانه نوشته شد که قابلِ تکرار نیست، چون به زمان‌بندیِ نخ‌ها بستگی داشت. **ساعتِ مجازی دقیقاً همان مشکل را از ریشه حل می‌کند:** وقتی زمان یک عددِ توی برنامه باشد، هیچ چیزی برای «شانس آوردن» باقی نمی‌ماند.

قاعده‌ای که از این به بعد رعایتش می‌کنیم: **هیچ جای کدِ سامانه مستقیم `time.time()` را صدا نمی‌زند.** همه از یک ساعت می‌پرسند، و در تولید آن ساعت زمانِ واقعی را برمی‌گرداند.

## ۲. کار، صف، و شکستی که قابلِ تکرار است

</div>

```python
import queue
import random
import sqlite3

model = fit_model(TRAIN[:800])
JOBS = [{"job_id": r["ticket_id"], "text": r["text"]} for r in TEST[:200]]
FAIL_RATE = 0.30


def downstream_fails(job_id, attempt):
    """شکستِ ساختگی ولی قطعی: هر جفتِ (کار، تلاش) قرعهٔ خودش را دارد."""
    return random.Random(f"{job_id}:{attempt}").random() < FAIL_RATE


DB = sqlite3.connect(str(WORK / "jobs.db"))
DB.execute("CREATE TABLE naive  (job_id TEXT, label TEXT)")
DB.execute("CREATE TABLE strict (job_id TEXT PRIMARY KEY, label TEXT)")
DB.execute("CREATE TABLE safe   (job_id TEXT PRIMARY KEY, label TEXT)")


def label_of(job):
    return model.predict([normalise(job["text"])])[0]


def insert_naive(job):
    DB.execute("INSERT INTO naive VALUES (?, ?)", (job["job_id"], label_of(job)))


def insert_safe(job):
    DB.execute("INSERT OR IGNORE INTO safe VALUES (?, ?)", (job["job_id"], label_of(job)))


def rows(table):
    return DB.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]


work = queue.PriorityQueue()
for i, job in enumerate(JOBS):
    work.put((0.0, i, job, 1))
print("اندازهٔ صف:", work.qsize())
ready_at, _, first, attempt = work.get_nowait()
print("اولین کار:", first["job_id"], "· آمادهٔ اجرا در:", ready_at, "· تلاش:", attempt)
```

```text
اندازهٔ صف: 200
اولین کار: TK-00062 · آمادهٔ اجرا در: 0.0 · تلاش: 1
```

<div dir="rtl">

`PriorityQueue` را انتخاب کردیم چون هر کار یک **زمانِ آمادگی** دارد و باید همیشه زودترینش را برداریم. عضوِ صف یک چهارتایی است: زمانِ آمادگی، یک شمارهٔ ترتیبی برای شکستنِ تساوی، خودِ کار، و شمارهٔ تلاش.

**و `downstream_fails` نکتهٔ ظریفِ این فصل است.** به‌جای یک `random` مشترک، برای هر جفتِ (کار، تلاش) یک قرعهٔ مستقل می‌ریزیم که فقط به نامِ آن جفت بستگی دارد. **پس دو آزمایشِ متفاوت دقیقاً همان شکست‌ها را می‌بینند** و مقایسه‌شان صادقانه است.

## ۳. زمان‌بند: صف، ساعت، و هیچ نخی

</div>

```python
def run_queue(insert, max_attempts=1, backoff=lambda attempt, job_id: 5.0):
    clock = Clock()
    work = queue.PriorityQueue()
    for i, job in enumerate(JOBS):
        work.put((0.0, i, job, 1))
    seq, done, dead, moments = len(JOBS), 0, [], []
    while True:
        try:
            ready_at, _, job, attempt = work.get_nowait()
        except queue.Empty:
            break
        clock.jump_to(ready_at)
        moments.append(clock.now())
        insert(job)                                   # عوارضِ جانبی، قبل از قدمی که می‌شکند
        if not downstream_fails(job["job_id"], attempt):
            done += 1
        elif attempt >= max_attempts:
            dead.append({"job_id": job["job_id"], "attempts": attempt})
        else:
            seq += 1
            work.put((clock.now() + backoff(attempt, job["job_id"]), seq, job, attempt + 1))
    return {"done": done, "dead": dead, "attempts": len(moments),
            "elapsed": clock.now(), "moments": moments}


DB.execute("DELETE FROM naive")
once = run_queue(insert_naive, max_attempts=1)
naive_once = rows("naive")

DB.execute("DELETE FROM naive")
thrice = run_queue(insert_naive, max_attempts=3)
naive_thrice = rows("naive")

print(f"بدونِ تلاشِ دوباره: {once['attempts']:>3} تلاش · {once['done']:>3} موفق"
      f" · {len(once['dead']):>2} شکست‌خورده")
print(f"با تا سه تلاش    : {thrice['attempts']:>3} تلاش · {thrice['done']:>3} موفق"
      f" · {len(thrice['dead']):>2} در صفِ نامه‌های مرده")
```

```text
بدونِ تلاشِ دوباره: 200 تلاش · 143 موفق · 57 شکست‌خورده
با تا سه تلاش    : 273 تلاش · 194 موفق ·  6 در صفِ نامه‌های مرده
```

<div dir="rtl">

**۵۷ کارِ ازدست‌رفته به ۶ رسید، با ۷۳ تلاشِ اضافه.**

ریاضی‌اش هم شهودی است: هر تلاش با احتمالِ ۰٫۳ می‌شکند، پس شکستنِ سه تلاشِ پشتِ سرِ هم احتمالش ۰٫۳ به توانِ ۳ است، یعنی حدودِ ۲٫۷ صدم. **۶ از ۲۰۰ دقیقاً همان‌جاست.**

**دو جملهٔ صادقانه دربارهٔ همین عدد:** اول اینکه تلاشِ دوباره فقط برای خطای **گذرا** جواب می‌دهد؛ اگر ورودی خراب باشد، هزار تلاش هم همان خطا را می‌دهد و فقط سرویس را اذیت می‌کند. دوم اینکه در تولید، تلاشِ دوباره را روی کدِ ۵۰۰ می‌زنی و روی ۴۰۰ **هرگز** — همان تفاوتی که در فصلِ قبل قرارداد اعلامش کرد.

> 🔧 **اگر کار نکرد:** اگر حلقه با `queue.Empty` نشکند و تا ابد بچرخد، شرطِ `attempt >= max_attempts` را جا انداخته‌ای و کارها بی‌نهایت بار به صف برمی‌گردند. پیامی که موقعِ درست‌کاری می‌بینی این است: `queue.Empty` بدونِ هیچ متنی — **این استثنا پیام ندارد و همین گیج‌کننده است.** ما به‌عمد از `get_nowait()` استفاده کردیم تا خالی شدنِ صف **همان لحظه** معلوم شود؛ `get()` معمولی تا ابد منتظر می‌ماند و نوت‌بوکت قفل می‌کند.

## ۴. قیمتِ پنهانِ تلاشِ دوباره

حالا به همان دو اجرا از زاویهٔ دیگری نگاه کنیم: به پایگاه داده.

</div>

```python
print("کارها                        :", len(JOBS))
print("ردیف‌ها، بدونِ تلاشِ دوباره   :", naive_once)
print("ردیف‌ها، با تا سه تلاش       :", naive_thrice)
print("ردیف‌های اضافه               :", naive_thrice - len(JOBS))
```

```text
کارها                        : 200
ردیف‌ها، بدونِ تلاشِ دوباره   : 200
ردیف‌ها، با تا سه تلاش       : 273
ردیف‌های اضافه               : 73
```

<div dir="rtl">

**دویست کار، دویست و هفتاد و سه ردیف.**

ترتیبِ کار در `run_queue` عمداً همان ترتیبِ دنیای واقعی است: **اول عوارضِ جانبی، بعد قدمی که ممکن است بشکند.** ردیف نوشته می‌شود، بعد اعلان به سرویسِ پایین‌دستی می‌رود و آن است که جواب نمی‌دهد. صف خبر ندارد که نصفِ کار انجام شده؛ فقط می‌بیند کار شکست خورده و از اول اجرایش می‌کند.

**اگر این «ردیف» به‌جای یک برچسب، یک پیامک یا یک برداشت از حساب بود، ۵۷ نفر دست‌کم دو بار پیام می‌گرفتند و ۱۶ نفرشان سه بار.** و هیچ خطایی هم در هیچ سیاهه‌ای نبود.

## ۵. یکسان‌توانی: کلیدی که تکرار را بی‌اثر می‌کند

راهِ حل این نیست که تلاشِ دوباره را برداریم — دیدیم چقدر ارزش دارد. راهِ حل این است که **کار را طوری بنویسیم که اجرای دومش هیچ چیزِ تازه‌ای نسازد.** به هر کار یک کلید می‌دهیم و پایگاه داده را وادار می‌کنیم آن کلید را یکتا نگه دارد.

</div>

```python
DB.execute("INSERT INTO strict VALUES (?, ?)", ("TK-00001", "پرداخت"))
try:
    DB.execute("INSERT INTO strict VALUES (?, ?)", ("TK-00001", "پرداخت"))
except sqlite3.IntegrityError as exc:
    print("sqlite3.IntegrityError:", exc)
```

```text
sqlite3.IntegrityError: UNIQUE constraint failed: strict.job_id
```

<div dir="rtl">

**این خطا خبرِ خوبی است.** پایگاه داده جلوی ردیفِ تکراری را گرفت — ولی به شکلی که کارِ ما را می‌شکند. برای یک کارِ ناهم‌زمان جوابِ درست «فریاد بزن» نیست، «بی‌سروصدا رد شو» است، چون ردیف **از قبل درست است**.

</div>

```python
DB.execute("DELETE FROM safe")
safe_run = run_queue(insert_safe, max_attempts=3)
print(f"تلاش‌ها: {safe_run['attempts']} · ردیف‌های جدولِ یکسان‌توان: {rows('safe')}")
print("هر کار دقیقاً یک ردیف دارد؟",
      DB.execute("SELECT COUNT(DISTINCT job_id) FROM safe").fetchone()[0] == rows("safe"))
```

```text
تلاش‌ها: 273 · ردیف‌های جدولِ یکسان‌توان: 200
هر کار دقیقاً یک ردیف دارد؟ True
```

<div dir="rtl">

**همان ۲۷۳ تلاش، همان شکست‌ها، همان تلاش‌های دوباره — و دقیقاً ۲۰۰ ردیف.**

تفاوت فقط دو چیز است: یک ستونِ `PRIMARY KEY` و یک `OR IGNORE`. **کلیدِ یکسان‌توانی هرچیزی می‌تواند باشد به شرطی که به خودِ کار وابسته باشد، نه به لحظهٔ اجرا:** شناسهٔ تیکت خوب است، شناسه‌ای که موقعِ ارسال ساخته می‌شود عالی است، و `uuid4()` که در **هر تلاش** از نو ساخته شود دقیقاً همان باگی است که می‌خواستیم از آن فرار کنیم.

> ✅ **چک کن:** به هر کارِ ناهم‌زمانِ خودت این سؤال را بزن: **«اگر این کار دقیقاً دو بار اجرا شود، از بیرون چه تفاوتی دیده می‌شود؟»** اگر جوابت «هیچ» است، یکسان‌توان است. اگر جوابت «دو ایمیل، دو ردیف، دو برداشت» است، **کلید ندارد** — و روزی که صف شلوغ شود، حتماً دو بار اجرا می‌شود.

> 📏 **اندازه بگیر:** **با چه چیزی مقایسه شد؟** با همان صف، همان ۲۰۰ کار و همان ۲۷۳ تلاش؛ تنها متغیر تعریفِ جدول بود. **روی کدام داده؟** دویست تیکتِ اولِ مجموعهٔ آزمون، یکسان در همهٔ اجراها. **با چند `seed`؟** یکی — و اینجا `seed` **اصلاً تصادفی نیست**: `downstream_fails` قرعه‌اش را از نامِ کار می‌سازد، پس روی هر ماشینی، در هر اجرا، **دقیقاً همان ۵۷ کار** شکست می‌خورند. این تفاوتِ «تصادفی» و «تکرارناپذیر» است.

## ۶. صفِ نامه‌های مرده

شش کار حتی با سه تلاش هم موفق نشدند. **اگر جایی برای رفتن نداشته باشند، بی‌سروصدا ناپدید می‌شوند** — و بدترین حالت این است که هیچ‌کس نداند شش تیکت هرگز پردازش نشد.

</div>

```python
print("کارهای مرده:", len(thrice["dead"]))
for item in thrice["dead"]:
    print("  ", item["job_id"], "· تلاش‌ها:", item["attempts"],
          "· قرعه‌ها:", [round(random.Random(f"{item['job_id']}:{a}").random(), 3)
                        for a in (1, 2, 3)])
```

```text
کارهای مرده: 6
   TK-00499 · تلاش‌ها: 3 · قرعه‌ها: [0.142, 0.161, 0.059]
   TK-00404 · تلاش‌ها: 3 · قرعه‌ها: [0.065, 0.241, 0.143]
   TK-01091 · تلاش‌ها: 3 · قرعه‌ها: [0.022, 0.176, 0.206]
   TK-00101 · تلاش‌ها: 3 · قرعه‌ها: [0.087, 0.298, 0.162]
   TK-00206 · تلاش‌ها: 3 · قرعه‌ها: [0.145, 0.048, 0.143]
   TK-00175 · تلاش‌ها: 3 · قرعه‌ها: [0.123, 0.16, 0.102]
```

<div dir="rtl">

هر شش‌تا هر سه قرعه‌شان زیرِ ۰٫۳ افتاده — یعنی واقعاً بدشانس بوده‌اند، نه اینکه باگی در کد باشد. **صفِ نامه‌های مرده باید همین را نگه دارد: نه فقط کار، بلکه شواهدِ اینکه چرا مرد.**

**سه قاعدهٔ عملی برای این صف:** تعدادش را **پایش** کن (رشدِ ناگهانی یعنی خرابیِ بالادستی)، **قابلِ اجرای دوباره** نگهش دار (بعد از رفعِ مشکل باید بشود همه را برگرداند)، و اگر کارها یکسان‌توان باشند این اجرای دوباره **بی‌خطر** است. **اینجا همهٔ تکه‌های فصل به هم می‌رسند.**

## ۷. عقب‌نشینی و `jitter`، با عدد

تا حالا هر تلاشِ دوباره را ۵ ثانیه بعد گذاشتیم. **نتیجه‌اش این است که هر ۵۷ کارِ شکست‌خورده دقیقاً در یک لحظه برمی‌گردند** — درست وقتی سرویسِ پایین‌دستی هنوز حالش خوب نیست.

</div>

```python
def busiest_second(moments, width=1.0):
    counts = {}
    for t in moments:
        bucket = int(t // width)
        counts[bucket] = counts.get(bucket, 0) + 1
    return max(counts.values())


def with_jitter(attempt, job_id):
    base = 5.0 * (2 ** (attempt - 1))                 # ۵ ثانیه، ۱۰ ثانیه، ...
    return base * (1 + random.Random(f"jitter:{job_id}:{attempt}").random())


DB.execute("DELETE FROM safe")
flat = run_queue(insert_safe, max_attempts=3)
DB.execute("DELETE FROM safe")
spread = run_queue(insert_safe, max_attempts=3, backoff=with_jitter)

for name, run in (("ثابت، بدونِ jitter", flat), ("نمایی، با jitter ", spread)):
    later = [t for t in run["moments"] if t > 0]
    print(f"{name}: زمانِ مجازیِ کل {run['elapsed']:>6.1f} ثانیه"
          f" · شلوغ‌ترین ثانیهٔ تلاشِ دوباره {busiest_second(later):>3}")
```

```text
ثابت، بدونِ jitter: زمانِ مجازیِ کل   10.0 ثانیه · شلوغ‌ترین ثانیهٔ تلاشِ دوباره  57
نمایی، با jitter : زمانِ مجازیِ کل   28.3 ثانیه · شلوغ‌ترین ثانیهٔ تلاشِ دوباره  17
```

<div dir="rtl">

**اوجِ بار از ۵۷ به ۱۷ رسید — و کلِ کار به‌جای ۱۰ ثانیه، ۲۸ ثانیه طول کشید.**

این یک معامله است، نه یک بهبودِ رایگان: **عقب‌نشینیِ نمایی و `jitter` گذردهی را نمی‌خرند، فشارِ لحظه‌ایِ روی سرویسِ بیمار را می‌خرند.** اگر سرویسِ پایین‌دستی به‌خاطرِ بار افتاده باشد، برگرداندنِ ۵۷ درخواست در یک ثانیه دقیقاً همان کاری است که دوباره زمینش می‌زند.

> 🌱 **ریشه‌اش کجاست:** آن `5.0 * (2 ** (attempt - 1))` همان تابعِ [ریشه، ترم ۴ فصل ۷ — رشدِ نمایی، و چرا شهود شکست می‌خورد](/courses/risheh/lessons/term-4-functions/session-07-exponential) است، و همان فصل هشدارش را هم می‌دهد: **«در رشدِ نمایی هیچ درصدی کوچک نیست؛ فقط زمان لازم دارد.»** اینجا این خاصیت **به نفعِ ماست** — پنجم و ششمِ تلاش‌ها آن‌قدر عقب می‌افتند که دیگر ازدحامی نمی‌سازند — **ولی همان خاصیت دامِ خودش را هم دارد:** با سقفِ تلاشِ بالا، آخرین تلاش می‌تواند ساعت‌ها بعد بیفتد. **به همین دلیل در تولید کنارِ عقب‌نشینیِ نمایی همیشه یک سقفِ زمانی می‌گذارند، نه فقط سقفِ تعداد.**

**و توجه کن که ۲۸٫۳ ثانیه یک عددِ واقعی است، نه تخمین** — همهٔ این آزمایش در کسری از ثانیه اجرا شد، چون تنها ساعتی که در کار بود ساعتِ خودمان بود.

> 🤖 **از دستیارت بپرس:** «تفاوتِ `at-least-once` و `exactly-once` در سامانه‌های صف چیست و چرا `exactly-once` واقعی تقریباً همیشه یک ادعاست؟» جوابِ درست به «تحویلِ حداقل یک بار، پردازشِ یکسان‌توان» می‌رسد. بعد این را بپرس: **«اگر عوارضِ جانبیِ کارِ من ارسالِ ایمیل باشد و پایگاه داده نداشته باشم، کلیدِ یکسان‌توانی را کجا نگه دارم؟»**

## واژه‌های تازهٔ این فصل

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| virtual clock | ویرچوال کلاک | ساعتی داخلِ برنامه که خودت جلویش می‌بری |
| worker | ورکر | جزئی که کارها را از صف برمی‌دارد و انجام می‌دهد |
| retry | ری‌ترای | اجرای دوبارهٔ کاری که شکست خورده |
| idempotent | آیدم‌پوتنت | کاری که اجرای دوباره‌اش هیچ اثرِ تازه‌ای نمی‌گذارد |
| idempotency key | آیدم‌پوتنسی کی | شناسه‌ای که دو اجرای یک کار را یکی می‌کند |
| dead letter queue | دِد لِتِر کیو | جایی که کارِ چندبار شکست‌خورده می‌رود تا گم نشود |
| exponential backoff | اکسپوننشال بک‌آف | دو برابر شدنِ فاصلهٔ تلاش‌های پیاپی |
| jitter | جیتر | پراکندنِ تصادفیِ زمانِ تلاش‌ها تا با هم برنگردند |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا `uuid4()` که در هر تلاش ساخته شود کلیدِ یکسان‌توانیِ بدی است؟

**تمرینِ اجباری:** `max_attempts` را ۱ و ۲ و ۳ و ۵ بگذار و برای هرکدام **سه عدد** گزارش کن: تعدادِ کارهای موفق، تعدادِ کلِ تلاش‌ها، و اندازهٔ صفِ نامه‌های مرده. **جدولت را نگاه کن و جواب بده: از کدام عدد به بعد، هر تلاشِ اضافه کمتر از یک کار را نجات می‌دهد؟** این همان جایی است که در تولید سقفِ تلاش را می‌گذاری.

**تمرینِ ستاره‌دار ⭐:** یک عارضهٔ جانبیِ **غیریکسان‌توان** به کار اضافه کن که پایگاه داده نیست: مثلاً یک شمارندهٔ سراسری به نامِ `sms_sent` که هر بار یکی زیاد می‌شود. حالا با تا سه تلاش اجرا کن و عددش را گزارش کن. بعد **یکسان‌توانش کن** — و شرطِ پذیرش این است که راه‌حلت **حتی اگر برنامه وسطِ کار بمیرد** درست بماند. **راهنمایی: ترتیبِ «اول ثبت کن که فرستادم، بعد بفرست» و «اول بفرست، بعد ثبت کن» دو باگِ متفاوت می‌سازند. هر دو را بنویس و بگو کدام را قبول می‌کنی.**

## در فصل بعد

صف بارِ سنگین را از سرِ راهِ کاربر برداشت. فصلِ بعد سراغِ بارِ سبک ولی **تکراری** می‌رود: `cache`. نرخِ اصابت را اندازه می‌گیریم، و بعد گران‌ترین اشتباهِ این حوزه را نشان می‌دهیم — **یک `cache` که بعد از عوض شدنِ نسخهٔ مدل، ۴۸ جواب از هر هزار درخواست را با مدلِ بازنشسته و با اطمینانِ کامل تحویل می‌دهد.**

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t4/s04-batch-and-queue (یادستان, Yaadestan)
