البرمجة غير المتزامنة

طريقان إلى نفس الفكرة

الأساسيات المطلوبة

المفاهيم الأساسية

فكرة هذا الجزء كلها في جملة واحدة: معظم بطء البرامج ليس حسابًا، بل انتظارًا. وحين يكون البطء انتظارًا، لا تحتاج معالجًا أسرع ولا خيوطًا إضافية؛ تحتاج فقط أن يستفيد البرنامج من فترات الانتظار بدل أن يقف فيها.

1نوعان من البطء: انتظار أم حساب؟

قبل أي شيء، صنّف مشكلتك، لأن العلاج يختلف تمامًا:

2التزامن ليس التوازي

الخلط بينهما سبب معظم التوقعات الخاطئة:

‏asyncio يعطيك تزامنًا بلا توازٍ: خيط واحد، لحظة واحدة ينفّذ فيها كوروتين واحد فقط، لكن لا أحد يقف منتظرًا. ولهذا السبب تحديدًا لا يوجد في asyncio «سباق على المتغيّرات» بالمعنى الذي تخافه في الخيوط: التبديل بين المهام لا يحدث إلا عند await‏، وأنت من يكتب مكانه.

3الكوروتين: دالة تعرف كيف توقف نفسها

الدالة العادية حين تبدأ لا تتوقف حتى تنتهي. الكوروتين (coroutine) يستطيع أن يقول «سأنتظر شيئًا، خذوا الدور ولا تضيعوا وقتي»، ثم يُستأنف لاحقًا من نفس السطر بكل متغيّراته سليمة.

4حلقة الأحداث: المدير الذي ينظّم الدور

حلقة الأحداث (event loop) هي قلب asyncio: حلقة واحدة تحتفظ بقائمة المهام الجاهزة، تعطي كل مهمة الدور حتى تتوقف عند await‏، فتأخذ الدور منها وتعطيه لمهمة أخرى. وحين لا يوجد أحد جاهز، تنام حتى يصل ردّ شبكة أو ينتهي مؤقّت.

‏asyncio.run(main()) هو من يفتح الحلقة ويشغّل main فيها ثم يغلقها. هذه نقطة الدخول الوحيدة الموصى بها، وتُستدعى مرة واحدة من كود متزامن عادي، لا من داخل كوروتين.

5async وawait‏: ماذا يفعل كل منهما

6ثلاث طرق لتشغيل عدة كوروتينات (والفرق بينها جوهري)

7الكوروتين مقابل المهمة (Task)

الفرق في لحظة البدء:

لهذا تُكتب دالة تُرجع مهمة بـdef عادية لا async def‏: create_task لا يحتاج انتظارًا، فهو يسجّل المهمة ويعيدها فورًا؛ ولو جعلت الدالة async لأصبح على المستدعي أن ينتظرها ليحصل على المهمة، وهذه طبقة انتظار بلا فائدة.

8قياس الزمن: ماذا تقيس بالضبط

استخدم time.perf_counter() لا time.time()‏: الأول ساعة رتيبة مخصّصة لقياس الفروق ولا تتأثر بتعديل ساعة النظام. والقياس الصحيح يحيط بـasyncio.run(...) كاملًا، لأن ما تريد معرفته هو الزمن الحقيقي الذي انتظره المستخدم.

9التعليقات النوعية على الكوروتينات

مشاريعك تُصحّح على بايثون 3.8، وهذا يفرض قواعد محدّدة:

كيف يعمل هذا فعليًا، خطوة بخطوة

أربع صور تختصر الفكرة: أين يذهب الوقت، وما الحالات التي يمرّ بها الكوروتين، وماذا يجري داخل الحلقة عند await‏، ومتى يكون asyncio هو الجواب أصلًا.

الرسم 36: أين يذهب الوقت: في الحالة A الانتظاران متتاليان فيتجمّعان، وفي الحالة B يتداخلان فيحكمهما أطولهما. لاحظ أن العمل نفسه لم يتغيّر، تغيّر ترتيب الانتظار فقط.

الرسم 37: دورة حياة الكوروتين. الحالة الأولى هي سبب تحذير «‏was never awaited‏»: كائن بقي عند C ولم ينتقل أبدًا.

الرسم 38: ما يحدث داخل gather‏. التبديل بين المهام لا يحدث إلا عند await‏؛ ولهذا لو احتوى أحدها على حساب ثقيل بلا await لتوقّف كل شيء.

الرسم 39: شجرة القرار. السؤال الأول ليس «هل أستخدم async؟» بل «أين يضيع الوقت؟»، والإجابة عليه تحدّد الأداة.

1. اكتب دوالك التي تنتظر بـasync def واجعل كل انتظار فيها await‏.
2. اجمع ما يمكن تشغيله معًا في gather أو as_completed‏، لا في حلقة for مع await داخلها.
3. استخدم create_task حين تريد أن يبدأ عمل في الخلفية بينما تكمل أنت.
4. شغّل كل شيء من نقطة دخول واحدة: asyncio.run(main())‏.
5. قِس بـperf_counter قبل أن تصدّق أنك ربحت شيئًا.

مثال محلول: مقهى يحضّر الطلبات معًا

سنبقى في مقهانا من الأجزاء السابقة، لكن هذه المرة المشكلة هي الزمن. كل كود ومخرَج تحته نُفِّذ فعليًا، والأرقام حقيقية لا تقديرية.

الخطوة 1: المشكلة، طلبان بالتتابع

import asyncio, time

async def brew(name, secs):
    await asyncio.sleep(secs)          # يمثّل انتظارًا حقيقيًا: ماكينة، شبكة، قرص
    return f"{name} ready after {secs}s"

async def sequential():
    t0 = time.perf_counter()
    a = await brew("espresso", 1)      # نقف هنا ثانية كاملة
    b = await brew("latte", 2)         # ثم ثانيتين أخريين
    return round(time.perf_counter() - t0, 2), [a, b]

print("sequential:", asyncio.run(sequential()))
# sequential: (3.0, ['espresso ready after 1s', 'latte ready after 2s'])

ثلاث ثوانٍ. لاحظ أن الكود مكتوب بـasync بالكامل ومع ذلك لم يربح شيئًا: مجرد كتابة async لا تعطي تزامنًا، التزامن يأتي من تشغيل الأشياء معًا.

الخطوة 2: نفس العمل بـgather

async def concurrent():
    t0 = time.perf_counter()
    res = await asyncio.gather(brew("espresso", 1), brew("latte", 2))
    return round(time.perf_counter() - t0, 2), res

print("concurrent:", asyncio.run(concurrent()))
# concurrent: (2.0, ['espresso ready after 1s', 'latte ready after 2s'])

ثانيتان بدل ثلاث: الزمن صار أطول الانتظارين لا مجموعهما. ولو كان لدينا عشرة مشروبات أطولها ثانيتان، لبقي الزمن ثانيتين.

الخطوة 3: الكوروتين لا يعمل حتى تنتظره

c = brew("x", 0)
print("type:", type(c).__name__)       # type: coroutine
c.close()                              # أغلقناه يدويًا حتى لا يطبع تحذيرًا

استدعاء الدالة أنتج كائنًا فقط. لم يُنفَّذ سطر واحد من جسمها.

الخطوة 4: gather يحفظ ترتيب الوسائط لا ترتيب الانتهاء

async def finish_order():
    order = []
    async def job(n, d):
        await asyncio.sleep(d)
        order.append(n)                # نسجّل من انتهى فعلًا ومتى
        return n
    got = await asyncio.gather(job("slow", 0.3), job("fast", 0.1))
    return got, order

print(asyncio.run(finish_order()))
# (['slow', 'fast'], ['fast', 'slow'])

النتيجة ['slow', 'fast'] بترتيب ما كتبته، بينما ترتيب الانتهاء الحقيقي كان ['fast', 'slow']‏. هذه ليست مشكلة، هذه ميزة: تستطيع مطابقة النتائج بمدخلاتها بالفهرس.

الخطوة 5: as_completed وسرّ الترتيب التصاعدي

import random
random.seed(7)

async def random_delay(max_delay=10):
    d = random.uniform(0, max_delay)   # 0 <= d <= max_delay
    await asyncio.sleep(d)
    return d

async def gather_delays(n, max_delay):
    out = []
    for done in asyncio.as_completed([random_delay(max_delay) for _ in range(n)]):
        out.append(await done)         # يصل كل واحد لحظة انتهائه
    return out

res = asyncio.run(gather_delays(5, 3))
print([round(x, 3) for x in res])      # [0.217, 0.453, 0.971, 1.608, 1.953]
print(res == sorted(res))              # True   بلا sort()

وللمقارنة المباشرة، نفس الدالة بـgather‏:

async def wait_n_gather(n, max_delay):
    return await asyncio.gather(*(random_delay(max_delay) for _ in range(n)))

res2 = asyncio.run(wait_n_gather(5, 3))
print([round(x, 3) for x in res2])     # [1.097, 0.174, 1.522, 0.112, 1.301]
print(res2 == sorted(res2))            # False

الخطوة 6: create_task يبدأ فورًا

async def demo():
    t0 = time.perf_counter()
    coro = random_delay(1)                        # لم يُجدول بعد
    task = asyncio.create_task(random_delay(1))   # جُدول الآن وبدأ
    await asyncio.sleep(0.4)
    print("  after 0.4s -> task done?", task.done(), "| type:", type(task).__name__)
    a = await task
    b = await coro
    return round(time.perf_counter() - t0, 2)

print("total:", asyncio.run(demo()), "s")
#   after 0.4s -> task done? True | type: Task
# total: 0.95 s

المهمة تقدّمت وانتهت بينما كنا ننتظر شيئًا آخر، والكوروتين بقي ساكنًا حتى جاء دوره. انتبه: create_task يتطلّب حلقة تعمل، فلا تستدعه خارج asyncio.run‏.

الخطوة 7: الإلغاء

async def cancel_demo():
    t = asyncio.create_task(asyncio.sleep(5))
    await asyncio.sleep(0.1)
    t.cancel()
    try:
        await t
    except asyncio.CancelledError:
        return "CancelledError raised, loop kept running"

print(asyncio.run(cancel_demo()))
# CancelledError raised, loop kept running

الإلغاء يصلك كاستثناء داخل المهمة، وهذا ما يجعل finally مكانًا موثوقًا لإغلاق اتصال أو ملف حتى لو أُلغيت المهمة في منتصفها.

الخطوة 8: نسيان await

async def oops():
    random_delay(1)      # لا await: الجسم لن يعمل أبدًا
    return "body of random_delay never ran"

# المخرج: body of random_delay never ran | warning: RuntimeWarning

لا خطأ ولا انهيار، فقط تحذير سهل التجاهل ونصف منطق مفقود. إذا رأيت coroutine ... was never awaited فابحث عن استدعاء ناقص await‏.

الخطوة 9: قياس متوسط الزمن لكل عملية

def time_runs(n, max_delay):          # def عادية، لا async
    t0 = time.perf_counter()
    asyncio.run(gather_delays(n, max_delay))    # القياس يحيط بالتشغيل كاملًا
    return (time.perf_counter() - t0) / n

لماذا ينزل الناتج كلما كبر n؟ لأن البسط (الزمن الكلي) يقترب من أطول انتظار ويكاد لا يتغيّر، بينما المقام n يكبر. وهذا القسمة نفسها مقياس جميل لمقدار ما ربحته من التزامن.

الخطوة 10: استدعاء محجوب يجمّد كل شيء

async def good(): await asyncio.sleep(0.5)   # يعيد الدور
async def bad():  time.sleep(0.5)            # يحتجز الخيط كله

# await asyncio.gather(good(), good())  ->  0.5 s
# await asyncio.gather(bad(),  bad())   ->  1.0 s

نفس البنية ونفس gather‏، والفرق مضاعفة الزمن. القاعدة: داخل كوروتين، كل انتظار يجب أن يكون بـawait على نسخة غير متزامنة؛ وما لا يملك نسخة غير متزامنة يُنقل خارج الحلقة بـloop.run_in_executor‏.

أسطورة وحقيقة

أين يُستخدم هذا عمليًا؟

جرّب بنفسك

بطاقات مراجعة سريعة

تحقّق من فهمك