مرزِ shield در پایتون؛ لغوِ منتظر و عمرِ Task داخلی

در یک برنامهٔ ناهمگام، پایانِ انتظارِ یک وظیفه الزاماً پایانِ کاری نیست که منتظرش بوده است. این تفاوت برای فهمِ مالکیتِ کارهای باقی‌مانده مهم است: چه کسی نتیجه را می‌گیرد، خطا را می‌بیند و پایان را انتظار می‌کشد؟ در این درس، با Taskهای واقعی و دروازه‌های صریح، مرزِ shield را بررسی می‌کنیم. دادهٔ میلی‌ولتی کاملاً ساختگی است؛ زمان، شبکه یا دستگاهی اندازه‌گیری نمی‌شود.

۱. لغوِ منتظر با لغوِ کارِ داخلی یکی نیست

سه نقش داریم: هماهنگ‌کنندهٔ آزمایش، کارِ داخلی و Task منتظر. کارِ داخلی پس از اعلامِ شروع، پشت یک Event می‌ماند و قرار است عدد۱۲۱۰ میلی‌ولت برگرداند. منتظر، پایانِ همان کار را await می‌کند. هماهنگ‌کننده هر دو Task را نگه می‌دارد و فقط پس از رسیدنِ هر دو به نقطهٔ مشخص، درخواستِ لغو را می‌فرستد. بنابراین عددِ۱۲۱۰، دادهٔ ساختگیِ خروجی است؛ نامِ Taskها یا وضعیتِ پایان، واحدِ ولتاژ ندارند.

در مسیرِ کنترل، منتظر مستقیماً کارِ داخلی را await می‌کند. لغوِ منتظر به کارِ داخلی منتقل می‌شود؛ آن کار CancelledError را پس از ثبتِ مشاهده دوباره عبور می‌دهد و finally اجرا می‌شود. سپس هر دو Task پایان‌یافته و لغوشده‌اند. ثبتِ finally فقط یک شمارندهٔ درون برنامه است؛ بستنِ واقعیِ فایل، درایور یا کانالِ حسگر را اثبات نمی‌کند.

در آزمونِ عمر TaskGroup، لغوِ فرزندانِ مرتبط و انتظار برای پایانِ آن‌ها بررسی شده بود. اینجا کارِ داخلی عمداً یک Task مستقل با مالکِ مشخص است و سؤال، مسیرِ انتقالِ لغو از منتظر است. TaskGroup، shield و مدیریتِ عمر منبع مسئولیت‌های یکسانی ندارند؛ افزودن یک پوشاننده، به‌تنهایی صاحبِ کارِ باقی‌مانده را تعیین نمی‌کند.

۲. shield کدام مرزِ لغو را نگه می‌دارد؟

وقتی منتظر از await asyncio.shield(inner) استفاده کند، لغوِ همان منتظر، کارِ داخلی را از این مسیر لغو نمی‌کند. با این حال خودِ await در منتظر همچنان CancelledError دارد؛ منتظر موفق اعلام نمی‌شود. بخشِ کاملِ shield و قراردادِ لغو در مرجع پایتون همین جدایی را بیان می‌کند. اسمِ shield را نباید تضمینِ مصونیتِ کار از هر نوعِ لغو دانست.

در نقطهٔ پس از پایانِ منتظر، کارِ داخلی هنوز پشت دروازه است: done و cancelled هر دو false و شمارِ finally صفر است. سپس هماهنگ‌کننده دروازه را باز می‌کند و خودش نتیجهٔ۱۲۱۰ را از await کارِ داخلی می‌گیرد. منتظرِ قبلی همچنان لغوشده می‌ماند؛ await دوبارهٔ آن نیز CancelledError دارد. رسیدنِ نتیجهٔ دیرتر، تاریخچهٔ منتظر را به موفقیت تبدیل نمی‌کند.

آزمایشِ جدا، مستقیماً خودِ inner را لغو می‌کند. در این حالت، منتظرِ دارای shield نیز CancelledError می‌بیند و کارِ داخلی بسته می‌شود. پس محافظت، تنها دربارهٔ مسیرِ لغوِ منتظرِ مشخص است. برنامهٔ ما هم لغو را به TimeoutError تبدیل نمی‌کند، هم uncancel صدا نمی‌زند؛ timeout و رفتارِ coroutineای که لغو را می‌بلعد، در قراردادِ آزمایش‌شده نیستند.

۳. ارجاع و پایانِ کارِ باقی‌مانده را رها نکنیم

مرجعِ رسمی تأکید می‌کند ارجاعِ Task را نگه داریم؛ حلقهٔ رویداد فقط ارجاعِ ضعیف نگه می‌دارد. مثالِ ما متغیرهای inner و waiter را تا پایانِ مشاهده حفظ می‌کند و هر دو را await می‌کند. ادامه‌داشتنِ کار به معنیِ دریافتِ خودکارِ نتیجه یا رسیدگیِ خودکارِ خطای آن نیست. این مسئولیت را در هماهنگ‌کننده صریح نگه می‌داریم و وعدهٔ اجرای رهاشدهٔ مطمئن نمی‌دهیم.

در یک حالت، پس از لغوِ منتظر، کارِ داخلی عمداً ValueError می‌دهد. هماهنگ‌کننده همان شیء خطا را از await بعدی می‌گیرد؛ خطا موفقیت نیست. در اجرای واقعیِ CPython3.14.5، چهار پیامِ تشخیصیِ «ValueError exception in shielded future» نیز روی stderr ثبت شدند: سه حالتِ جدول و یک شاهدِ جدا. با وجودِ دریافتِ بعدیِ خطا، این پیام‌ها واقعاً دیده شدند و حذف یا مخفی نشده‌اند.

بازبینیِ دو تابعِ مرتبط در کتابخانهٔ نصب‌شده نشان داد پس از لغوِ پوشاننده، callback می‌تواند خطای کارِ داخلی را به handler حلقه گزارش کند. این توضیح، مشاهدهٔ همین نسخه و فایلِ ثبت‌شده است؛ قراردادِ عمومیِ سکوتِ stderr یا رفتارِ همهٔ ساخت‌ها نیست. گرفتنِ نتیجه یا خطا در برنامه را با نبودِ پیامِ تشخیصی یکی نمی‌گیریم. هیچ handler سفارشی برای ساکت‌کردنِ آزمایش نصب نشده است.

مرجعِ کاملِ Event، set و wait را توضیح می‌دهد. دروازه‌ها ترتیبِ موردنیاز را قابل مشاهده می‌کنند؛ sleep، ساعت و مهلتِ سپری‌شده نداریم. در درسِ ContextVar و مرزِ ساخت Task نیز از هماهنگیِ صریح استفاده شد، اما آنجا اتصالِ برچسب‌ها موضوع بود؛ اینجا پایانِ منتظر و کار را جدا می‌سنجیم.

۴. کد کامل و جدولِ مستقلِ حالت‌ها

فایل زیر با CPython3.14.5 و فقط کتابخانهٔ استاندارد، یک‌بار اجرا شده است؛ مرجعِ خوانده‌شده نسخهٔ3.14.8 را نمایش می‌دهد. خروجیِ JSON و stderr جدا ذخیره شده‌اند. برنامه با کدِ خروجِ صفر تمام شد و همهٔ دوازده گروه گذشتند؛ چهار پیامِ توضیح‌داده‌شده روی stderr باقی ماندند. پس «گروه‌های موفق» را به‌اشتباه «اجرای بی‌پیام» گزارش نمی‌کنیم.

"""Controlled shield lifetime experiment; synthetic millivolts, no I/O/timers."""
import asyncio
import json
import platform


def validate_case(protected, action, millivolts, target):
    if type(protected) is not bool:
        raise TypeError("protected must be exact bool")
    if type(action) is not str or action not in ("return", "error", "cancel"):
        raise ValueError("action must be one declared exact string")
    if type(target) is not str or target not in ("waiter", "inner"):
        raise ValueError("target must be waiter or inner")
    if type(millivolts) is not int:
        raise TypeError("exact integer millivolts required")
    if not -10000 <= millivolts <= 10000:
        raise ValueError("millivolts outside teaching range")


async def observe_case(protected, action, millivolts, target="waiter"):
    """Own bounded fixture, not a general-purpose arbitrary-coroutine API."""
    validate_case(protected, action, millivolts, target)
    started = asyncio.Event()
    entered = asyncio.Event()
    release = asyncio.Event()
    state = {"finally_count": 0, "cancel_observed": False, "action_reached": False}
    authored_error = ValueError("authored inner failure")

    async def worker():
        try:
            started.set()
            await release.wait()
            state["action_reached"] = True
            if action == "error":
                raise authored_error
            if action == "cancel":
                raise asyncio.CancelledError()
            return millivolts
        except asyncio.CancelledError:
            state["cancel_observed"] = True
            raise
        finally:
            state["finally_count"] += 1

    # The coordinator retains strong references to both owned Tasks.
    inner = asyncio.create_task(worker())

    async def wait_for_inner():
        entered.set()
        if protected:
            return await asyncio.shield(inner)
        return await inner

    waiter = asyncio.create_task(wait_for_inner())
    try:
        await started.wait()
        await entered.wait()
        before = {"inner_pending": not inner.done(), "waiter_pending": not waiter.done(),
                  "release_is_set": release.is_set()}
        accepted = (waiter if target == "waiter" else inner).cancel()
        try:
            await waiter
        except asyncio.CancelledError:
            waiter_outcome = "CancelledError"
        else:
            raise AssertionError("controlled cancellation did not reach waiter")
        after_waiter = {"inner_done": inner.done(), "inner_cancelled": inner.cancelled(),
                        "worker_finally_count": state["finally_count"]}
        try:
            inner.result()
        except asyncio.InvalidStateError:
            early_result = "InvalidStateError"
        except asyncio.CancelledError:
            early_result = "CancelledError"
        else:
            raise AssertionError("unreleased inner unexpectedly had a result")
        release.set()
        same_error = None
        try:
            value = await inner
            later = {"kind": "return", "millivolts": value}
        except asyncio.CancelledError:
            later = {"kind": "CancelledError", "millivolts": None}
        except ValueError as error:
            same_error = error is authored_error
            later = {"kind": "ValueError", "millivolts": None}
        try:
            await waiter
        except asyncio.CancelledError:
            repeated_wait = "CancelledError"
        else:
            repeated_wait = "returned"
        return {"before_cancel": before, "cancel_request_accepted": accepted,
                "waiter_outcome": waiter_outcome, "after_waiter": after_waiter,
                "early_inner_result": early_result, "later_inner_outcome": later,
                "same_authored_error_object": same_error,
                "final": {"waiter_done": waiter.done(), "waiter_cancelled": waiter.cancelled(),
                          "inner_done": inner.done(), "inner_cancelled": inner.cancelled(),
                          "worker_finally_count": state["finally_count"],
                          "worker_cancel_observed": state["cancel_observed"],
                          "worker_action_reached": state["action_reached"]},
                "reawait_finished_waiter": repeated_wait}
    finally:
        # Normal paths have already awaited both. Also retain ownership on error.
        release.set()
        for task in (waiter, inner):
            if not task.done():
                task.cancel()
        for task in (waiter, inner):
            try:
                await task
            except (asyncio.CancelledError, ValueError):
                pass


def literal_phase_oracle(protected, action, millivolts, target):
    """Authored finite state table; no asyncio, task flags, events or main helper."""
    survives = { (False, "waiter"): False, (True, "waiter"): True,
                 (False, "inner"): False, (True, "inner"): False }[(protected, target)]
    outcome_table = {"return": {"kind": "return", "millivolts": millivolts},
                     "error": {"kind": "ValueError", "millivolts": None},
                     "cancel": {"kind": "CancelledError", "millivolts": None}}
    return {"before_cancel": {"inner_pending": True, "waiter_pending": True,
                              "release_is_set": False},
            "cancel_request_accepted": True, "waiter_outcome": "CancelledError",
            "after_waiter": {"inner_done": not survives, "inner_cancelled": not survives,
                             "worker_finally_count": 0 if survives else 1},
            "early_inner_result": "InvalidStateError" if survives else "CancelledError",
            "later_inner_outcome": outcome_table[action] if survives else outcome_table["cancel"],
            "same_authored_error_object": True if survives and action == "error" else None,
            "final": {"waiter_done": True, "waiter_cancelled": True, "inner_done": True,
                      "inner_cancelled": not survives or action == "cancel",
                      "worker_finally_count": 1,
                      "worker_cancel_observed": not survives or action == "cancel",
                      "worker_action_reached": survives},
            "reawait_finished_waiter": "CancelledError"}


async def completed_probe():
    """Separate success control with an already-finished inner before cancel()."""
    started = asyncio.Event()
    release = asyncio.Event()
    closed = []
    async def worker():
        try:
            started.set()
            await release.wait()
            return 1210
        finally:
            closed.append("finally")
    inner = asyncio.create_task(worker())
    await started.wait()
    release.set()
    first = await asyncio.shield(inner)
    accepted_after_done = inner.cancel()
    second = await asyncio.shield(inner)
    return {"first_mv": first, "second_mv": second, "cancel_after_done": accepted_after_done,
            "done": inner.done(), "cancelled": inner.cancelled(), "finally_count": len(closed)}


async def _run():
    protected = await observe_case(True, "return", 1210)
    direct = await observe_case(False, "return", 1210)
    checks = {
        "shielded_waiter_cancels_while_unreleased_inner_remains_pending":
            protected["after_waiter"] == {"inner_done": False, "inner_cancelled": False,
                                          "worker_finally_count": 0},
        "direct_await_control_cancels_inner_and_runs_finally":
            direct["after_waiter"] == {"inner_done": True, "inner_cancelled": True,
                                       "worker_finally_count": 1},
    }
    cases = 0
    oracle_ok = True
    for shielded in (False, True):
        for target in ("waiter", "inner"):
            for action in ("return", "error", "cancel"):
                for value in (-10000, 0, 10000):
                    actual = await observe_case(shielded, action, value, target)
                    oracle_ok = oracle_ok and actual == literal_phase_oracle(shielded, action, value, target)
                    cases += 1
    checks["36_bounded_cases_match_independent_literal_phase_table_one_family"] = cases == 36 and oracle_ok
    cancelled_inner = await observe_case(True, "return", 1210, "inner")
    checks["direct_cancellation_of_inner_reaches_shield_waiter"] = (
        cancelled_inner["waiter_outcome"] == "CancelledError"
        and cancelled_inner["final"]["inner_cancelled"]
        and not cancelled_inner["final"]["worker_action_reached"])
    failed = await observe_case(True, "error", 1210)
    checks["retained_inner_error_is_explicitly_awaited_with_same_error_identity"] = (
        failed["later_inner_outcome"]["kind"] == "ValueError"
        and failed["same_authored_error_object"] is True
        and not failed["final"]["inner_cancelled"])
    self_cancelled = await observe_case(True, "cancel", 1210)
    checks["inner_can_cancel_itself_after_waiter_cancellation"] = (
        self_cancelled["later_inner_outcome"]["kind"] == "CancelledError"
        and self_cancelled["final"]["worker_action_reached"]
        and self_cancelled["final"]["worker_finally_count"] == 1)
    checks["later_inner_success_does_not_revive_cancelled_waiter"] = (
        protected["later_inner_outcome"] == {"kind": "return", "millivolts": 1210}
        and protected["reawait_finished_waiter"] == "CancelledError"
        and protected["final"]["waiter_cancelled"])
    checks["pending_and_cancelled_inner_result_access_have_distinct_errors"] = (
        protected["early_inner_result"] == "InvalidStateError"
        and direct["early_inner_result"] == "CancelledError")
    completed = await completed_probe()
    checks["uncancelled_shield_success_returns_same_synthetic_value_and_finishes"] = (
        completed["first_mv"] == completed["second_mv"] == 1210
        and completed["done"] and not completed["cancelled"] and completed["finally_count"] == 1)
    checks["cancel_of_already_done_task_is_false_and_does_not_undo_value"] = (
        completed["cancel_after_done"] is False and completed["second_mv"] == 1210)
    class IntChild(int):
        pass
    class StrChild(str):
        pass
    bad = [(1, "return", 1, "waiter"), (None, "return", 1, "waiter"),
           (True, None, 1, "waiter"), (True, "unknown", 1, "waiter"),
           (True, StrChild("return"), 1, "waiter"),
           (True, "return", True, "waiter"), (True, "return", 1.0, "waiter"),
           (True, "return", float("nan"), "waiter"), (True, "return", IntChild(1), "waiter"),
           (True, "return", -10001, "waiter"), (True, "return", 10001, "waiter"),
           (True, "return", 1, "unknown"), (True, "return", 1, StrChild("waiter"))]
    rejected = 0
    no_child_creation = True
    for args in bad:
        before = set(asyncio.all_tasks())
        try:
            await observe_case(*args)
        except (TypeError, ValueError):
            rejected += 1
        no_child_creation = no_child_creation and set(asyncio.all_tasks()) == before
    checks["strict_own_mode_action_value_target_profile_rejected_before_children_one_family"] = (
        rejected == len(bad) == 13 and no_child_creation)
    pending = [t for t in asyncio.all_tasks() if t is not asyncio.current_task() and not t.done()]
    checks["all_own_inner_and_waiter_tasks_awaited_no_pending_children_before_loop_exit"] = pending == []
    assert len(checks) == 12 and all(type(v) is bool and v for v in checks.values()), checks
    return {"python": platform.python_version(), "implementation": platform.python_implementation(),
            "fixture_scope": "owned finite Tasks; synthetic mV; no I/O, sleep, elapsed timer or thread",
            "shielded_waiter_cancel": protected, "direct_waiter_cancel": direct,
            "inner_cancelled_directly": cancelled_inner, "retained_inner_error": failed,
            "completed_success_control": completed,
            "independent_table_case_count_one_group": cases, "unique_check_groups": len(checks),
            "invalid_cases_inside_one_family": len(bad), "checks": checks}


if __name__ == "__main__":
    print(json.dumps(asyncio.run(_run()), indent=2, allow_nan=False))

ورودیِ تابعِ آزمایش محدود است: protected دقیقاً bool، عمل یکی از سه رشتهٔ return، error و cancel، هدف یکی از waiter و inner، و مقدار دقیقاً int در بازهٔ منفی ده‌هزار تا ده‌هزار میلی‌ولت. زیرنوعِ عدد و رشته، اعشار و NaN رد می‌شوند. اعتبارسنجی هنگام await و پیش از ساختِ فرزندان انجام می‌شود. این تابع، رابطِ عمومی برای هر coroutine یا رفتارِ نامعلومِ افزونه نیست.

مرجعِ مستقل، جدولِ چهار حالتِ «دارای shield یا مستقیم، لغوِ منتظر یا داخلی» است و asyncio، Event یا پرچمِ Task را فراخوانی نمی‌کند. دو حالتِ محافظت، دو هدف، سه عمل و سه مقدار،۳۶ سناریو می‌سازند که در یک گروه بررسی می‌شوند. نوعِ پایان، شمارِ finally، امکانِ رسیدن به عملِ داخلی و نتیجهٔ بعدی با آن جدول مقایسه می‌شوند؛ این جدول اثباتِ همهٔ زمان‌بندی‌های ممکن نیست.

{
  "python": "3.14.5",
  "implementation": "CPython",
  "fixture_scope": "owned finite Tasks; synthetic mV; no I/O, sleep, elapsed timer or thread",
  "shielded_waiter_cancel": {
    "before_cancel": {
      "inner_pending": true,
      "waiter_pending": true,
      "release_is_set": false
    },
    "cancel_request_accepted": true,
    "waiter_outcome": "CancelledError",
    "after_waiter": {
      "inner_done": false,
      "inner_cancelled": false,
      "worker_finally_count": 0
    },
    "early_inner_result": "InvalidStateError",
    "later_inner_outcome": {
      "kind": "return",
      "millivolts": 1210
    },
    "same_authored_error_object": null,
    "final": {
      "waiter_done": true,
      "waiter_cancelled": true,
      "inner_done": true,
      "inner_cancelled": false,
      "worker_finally_count": 1,
      "worker_cancel_observed": false,
      "worker_action_reached": true
    },
    "reawait_finished_waiter": "CancelledError"
  },
  "direct_waiter_cancel": {
    "before_cancel": {
      "inner_pending": true,
      "waiter_pending": true,
      "release_is_set": false
    },
    "cancel_request_accepted": true,
    "waiter_outcome": "CancelledError",
    "after_waiter": {
      "inner_done": true,
      "inner_cancelled": true,
      "worker_finally_count": 1
    },
    "early_inner_result": "CancelledError",
    "later_inner_outcome": {
      "kind": "CancelledError",
      "millivolts": null
    },
    "same_authored_error_object": null,
    "final": {
      "waiter_done": true,
      "waiter_cancelled": true,
      "inner_done": true,
      "inner_cancelled": true,
      "worker_finally_count": 1,
      "worker_cancel_observed": true,
      "worker_action_reached": false
    },
    "reawait_finished_waiter": "CancelledError"
  },
  "inner_cancelled_directly": {
    "before_cancel": {
      "inner_pending": true,
      "waiter_pending": true,
      "release_is_set": false
    },
    "cancel_request_accepted": true,
    "waiter_outcome": "CancelledError",
    "after_waiter": {
      "inner_done": true,
      "inner_cancelled": true,
      "worker_finally_count": 1
    },
    "early_inner_result": "CancelledError",
    "later_inner_outcome": {
      "kind": "CancelledError",
      "millivolts": null
    },
    "same_authored_error_object": null,
    "final": {
      "waiter_done": true,
      "waiter_cancelled": true,
      "inner_done": true,
      "inner_cancelled": true,
      "worker_finally_count": 1,
      "worker_cancel_observed": true,
      "worker_action_reached": false
    },
    "reawait_finished_waiter": "CancelledError"
  },
  "retained_inner_error": {
    "before_cancel": {
      "inner_pending": true,
      "waiter_pending": true,
      "release_is_set": false
    },
    "cancel_request_accepted": true,
    "waiter_outcome": "CancelledError",
    "after_waiter": {
      "inner_done": false,
      "inner_cancelled": false,
      "worker_finally_count": 0
    },
    "early_inner_result": "InvalidStateError",
    "later_inner_outcome": {
      "kind": "ValueError",
      "millivolts": null
    },
    "same_authored_error_object": true,
    "final": {
      "waiter_done": true,
      "waiter_cancelled": true,
      "inner_done": true,
      "inner_cancelled": false,
      "worker_finally_count": 1,
      "worker_cancel_observed": false,
      "worker_action_reached": true
    },
    "reawait_finished_waiter": "CancelledError"
  },
  "completed_success_control": {
    "first_mv": 1210,
    "second_mv": 1210,
    "cancel_after_done": false,
    "done": true,
    "cancelled": false,
    "finally_count": 1
  },
  "independent_table_case_count_one_group": 36,
  "unique_check_groups": 12,
  "invalid_cases_inside_one_family": 13,
  "checks": {
    "shielded_waiter_cancels_while_unreleased_inner_remains_pending": true,
    "direct_await_control_cancels_inner_and_runs_finally": true,
    "36_bounded_cases_match_independent_literal_phase_table_one_family": true,
    "direct_cancellation_of_inner_reaches_shield_waiter": true,
    "retained_inner_error_is_explicitly_awaited_with_same_error_identity": true,
    "inner_can_cancel_itself_after_waiter_cancellation": true,
    "later_inner_success_does_not_revive_cancelled_waiter": true,
    "pending_and_cancelled_inner_result_access_have_distinct_errors": true,
    "uncancelled_shield_success_returns_same_synthetic_value_and_finishes": true,
    "cancel_of_already_done_task_is_false_and_does_not_undo_value": true,
    "strict_own_mode_action_value_target_profile_rejected_before_children_one_family": true,
    "all_own_inner_and_waiter_tasks_awaited_no_pending_children_before_loop_exit": true
  }
}

result روی کارِ هنوز معلق InvalidStateError دارد؛ روی کارِ لغوشده CancelledError دارد. شاهدِ موفقِ بدونِ لغو نیز نشان می‌دهد پس از پایانِ کار، cancel مقدارِ false می‌دهد و نتیجهٔ قبلی را پس نمی‌گیرد. در انتهای همین آزمایش، فرزندِ معلقی باقی نمانده است. این کنترل‌ها به ورودی‌ها و مسیرهای تعریف‌شده محدودند؛ سرعت، تأخیرِ لغو، توقفِ اجباری یا موازی‌سازیِ پردازنده سنجیده نشده‌اند.

۵. چهار پرسش دربارهٔ نتیجه، خطا و مسئولیت

پرسش اول: آیا shield باعث می‌شود منتظرِ لغوشده عدد۱۲۱۰ را بگیرد؟ پاسخ: خیر؛ همان منتظر CancelledError می‌گیرد. هماهنگ‌کننده بعداً از خودِ Task داخلی عدد را می‌گیرد، زیرا ارجاعش را نگه داشته است. این دو await، دو مشاهدهٔ جدا هستند؛ خروجیِ دیرتر، منتظرِ پایان‌یافته را زنده نمی‌کند.

پرسش دوم: اگر خودِ کارِ داخلی را لغو کنیم چه می‌شود؟ پاسخ: آن لغو از shield عبور نکرده که مسدود شود؛ کارِ داخلی و منتظر هر دو با CancelledError تمام می‌شوند. شاهدِ دیگری نیز لغوِ درونی پس از بازشدنِ دروازه را ثبت می‌کند. بنابراین نامِ shield جای تعیینِ هدفِ cancel و مسئولِ پایانِ کار را نمی‌گیرد.

پرسش سوم: چرا با await کردنِ خطای داخلی هنوز پیام دیدیم؟ پاسخ: در ساختِ ثبت‌شده، callback جداگانهٔ shield خطا را به handler گزارش می‌کند؛ دریافتِ بعدیِ همان خطا آن پیام را خودکار پس نمی‌گیرد. چهار پیامِ عمدی و کلاسِ ValueError با فایلِ stderr نگه داشته شده‌اند. از این مشاهده، تضمینِ ثابتِ پیام‌ها در تمام نسخه‌ها نمی‌سازیم.

پرسش چهارم: پس از لغوِ منتظر می‌توان تابع را فوراً رها کرد؟ پاسخ: این آزمایش چنین سیاستی ندارد؛ هماهنگ‌کننده کارِ باقی‌مانده را آزاد و پایانش را صریحاً مشاهده می‌کند. در کاربردِ واقعی، مالکیت، لغوِ مستقل، رسیدگی به خطا و عمرِ منابع باید طراحی شوند. این مثال نه تراکنش است، نه تضمینِ تکمیلِ کار پس از پایانِ فرایند و نه راهکارِ جلوگیری از همهٔ لغوها.

منابع و مطالعهٔ بیشتر

• Python3.14.8؛ shield، لغو و وضعیت Task
• Python3.14.8؛ قرارداد کامل Event

بررسی منابع: ۲۸ مهر ۱۴۰۵. تحلیل‌ها و پیشنهادهای اجرایی، جمع‌بندی نویسنده‌اند.