حلقه رویداد AsyncIO: زمان‌بندی Coroutine در مقابل مدیریت Task

برنامه‌نویسی غیرهمزمان در توسعه نرم‌افزار مدرن اهمیت فزاینده‌ای پیدا کرده است و به برنامه‌ها این امکان را می‌دهد که چندین وظیفه را به صورت همزمان و بدون مسدود کردن رشته اصلی مدیریت کنند. کتابخانه asyncio پایتون یک چارچوب قدرتمند برای نوشتن کد غیرهمزمان فراهم می‌کند که حول مفهوم حلقه رویداد (event loop) ساخته شده است. درک اینکه حلقه رویداد چگونه coroutine‌ها را زمان‌بندی کرده و task‌ها را مدیریت می‌کند، برای ساخت برنامه‌های غیرهمزمان کارآمد و مقیاس‌پذیر بسیار حیاتی است.

درک حلقه رویداد AsyncIO

در قلب asyncio، حلقه رویداد قرار دارد. این یک مکانیزم تک‌رشته‌ای و تک‌فرایندی است که وظایف غیرهمزمان را مدیریت و اجرا می‌کند. آن را به عنوان یک توزیع‌کننده مرکزی در نظر بگیرید که اجرای بخش‌های مختلف کد شما را هماهنگ می‌کند. حلقه رویداد به طور مداوم عملیات غیرهمزمان ثبت‌شده را نظارت کرده و زمانی که آماده اجرا باشند، آن‌ها را اجرا می‌کند.

مسئولیت‌های کلیدی حلقه رویداد:

• زمان‌بندی Coroutine‌ها: تعیین زمان و نحوه اجرای coroutine‌ها.
• مدیریت عملیات ورودی/خروجی (I/O): نظارت بر سوکت‌ها، فایل‌ها و دیگر منابع I/O برای آمادگی.
• اجرای Callback‌ها: فراخوانی توابعی که برای اجرا در زمان‌های خاص یا پس از رویدادهای معین ثبت شده‌اند.
• مدیریت Task‌ها: ایجاد، مدیریت و پیگیری پیشرفت وظایف غیرهمزمان.

Coroutine‌ها: بلوک‌های سازنده کد غیرهمزمان

Coroutine‌ها توابع ویژه‌ای هستند که می‌توانند در نقاط خاصی از اجرای خود متوقف و دوباره از سر گرفته شوند. در پایتون، coroutine‌ها با استفاده از کلمات کلیدی async و await تعریف می‌شوند. وقتی یک coroutine به عبارت await می‌رسد، کنترل را به حلقه رویداد بازمی‌گرداند و به coroutine‌های دیگر اجازه اجرا می‌دهد. این رویکرد چندوظیفگی مشارکتی (cooperative multitasking) امکان همزمانی کارآمد را بدون سربار thread‌ها یا process‌ها فراهم می‌کند.

تعریف و استفاده از Coroutine‌ها:

یک coroutine با استفاده از کلمه کلیدی async تعریف می‌شود:

async def my_coroutine():
  print("Coroutine started")
  await asyncio.sleep(1)  # Simulate an I/O-bound operation
  print("Coroutine finished")

برای اجرای یک coroutine، باید آن را با استفاده از asyncio.run()، loop.run_until_complete() یا با ایجاد یک task (در ادامه بیشتر در مورد task‌ها صحبت خواهیم کرد) روی حلقه رویداد زمان‌بندی کنید:

async def main():
  await my_coroutine()

asyncio.run(main())

زمان‌بندی Coroutine: چگونه حلقه رویداد تصمیم می‌گیرد چه چیزی را اجرا کند

حلقه رویداد از یک الگوریتم زمان‌بندی برای تصمیم‌گیری در مورد اینکه کدام coroutine بعدی اجرا شود، استفاده می‌کند. این الگوریتم معمولاً بر اساس انصاف و اولویت است. وقتی یک coroutine کنترل را واگذار می‌کند، حلقه رویداد coroutine آماده بعدی را از صف خود انتخاب کرده و اجرای آن را از سر می‌گیرد.

چندوظیفگی مشارکتی:

asyncio بر چندوظیفگی مشارکتی تکیه دارد، به این معنی که coroutine‌ها باید به صراحت کنترل را با استفاده از کلمه کلیدی await به حلقه رویداد واگذار کنند. اگر یک coroutine برای مدت طولانی کنترل را واگذار نکند، می‌تواند حلقه رویداد را مسدود کرده و از اجرای coroutine‌های دیگر جلوگیری کند. به همین دلیل بسیار مهم است که اطمینان حاصل کنید coroutine‌های شما رفتار مناسبی دارند و به طور مکرر، به ویژه هنگام انجام عملیات وابسته به I/O، کنترل را واگذار می‌کنند.

استراتژی‌های زمان‌بندی:

حلقه رویداد معمولاً از یک استراتژی زمان‌بندی اولین ورودی، اولین خروجی (FIFO) استفاده می‌کند. با این حال، می‌تواند coroutine‌ها را بر اساس فوریت یا اهمیت آن‌ها نیز اولویت‌بندی کند. برخی از پیاده‌سازی‌های asyncio به شما اجازه می‌دهند تا الگوریتم زمان‌بندی را متناسب با نیازهای خاص خود سفارشی کنید.

مدیریت Task: بسته‌بندی Coroutine‌ها برای همزمانی

در حالی که coroutine‌ها عملیات غیرهمزمان را تعریف می‌کنند، task‌ها نماینده اجرای واقعی آن عملیات در حلقه رویداد هستند. یک task یک بسته‌بندی (wrapper) در اطراف یک coroutine است که قابلیت‌های اضافی مانند لغو کردن، مدیریت استثنا و بازیابی نتیجه را فراهم می‌کند. Task‌ها توسط حلقه رویداد مدیریت و برای اجرا زمان‌بندی می‌شوند.

ایجاد Task‌ها:

شما می‌توانید با استفاده از asyncio.create_task() یک task از یک coroutine ایجاد کنید:

async def my_coroutine():
  await asyncio.sleep(1)
  return "Result"

async def main():
  task = asyncio.create_task(my_coroutine())
  result = await task  # Wait for the task to complete
  print(f"Task result: {result}")

asyncio.run(main())

وضعیت‌های Task:

یک task می‌تواند در یکی از وضعیت‌های زیر باشد:

• در انتظار (Pending): Task ایجاد شده اما هنوز اجرای آن شروع نشده است.
• در حال اجرا (Running): Task در حال حاضر توسط حلقه رویداد در حال اجرا است.
• انجام شده (Done): Task اجرای خود را با موفقیت به پایان رسانده است.
• لغو شده (Cancelled): Task قبل از اینکه بتواند کامل شود، لغو شده است.
• استثنا (Exception): Task در حین اجرا با یک استثنا مواجه شده است.

لغو کردن Task:

شما می‌توانید با استفاده از متد task.cancel() یک task را لغو کنید. این کار یک CancelledError را در داخل coroutine ایجاد می‌کند و به آن اجازه می‌دهد تا قبل از خروج، منابع خود را پاکسازی کند. مدیریت صحیح CancelledError در coroutine‌های شما برای جلوگیری از رفتار غیرمنتظره بسیار مهم است.

async def my_coroutine():
  try:
    await asyncio.sleep(5)
    return "Result"
  except asyncio.CancelledError:
    print("Coroutine cancelled")
    return None

async def main():
  task = asyncio.create_task(my_coroutine())
  await asyncio.sleep(1)
  task.cancel()
  try:
    result = await task
    print(f"Task result: {result}")
  except asyncio.CancelledError:
    print("Task cancelled")

asyncio.run(main())

زمان‌بندی Coroutine در مقابل مدیریت Task: یک مقایسه دقیق

اگرچه زمان‌بندی coroutine و مدیریت task در asyncio ارتباط نزدیکی با هم دارند، اما اهداف متفاوتی را دنبال می‌کنند. زمان‌بندی coroutine مکانیزمی است که توسط آن حلقه رویداد تصمیم می‌گیرد کدام coroutine بعدی اجرا شود، در حالی که مدیریت task فرآیند ایجاد، مدیریت و پیگیری اجرای coroutine‌ها به عنوان task است.

زمان‌بندی Coroutine:

• تمرکز: تعیین ترتیبی که coroutine‌ها اجرا می‌شوند.
• مکانیزم: الگوریتم زمان‌بندی حلقه رویداد.
• کنترل: کنترل محدود بر فرآیند زمان‌بندی.
• سطح انتزاع: سطح پایین، تعامل مستقیم با حلقه رویداد.

مدیریت Task:

• تمرکز: مدیریت چرخه حیات coroutine‌ها به عنوان task.
• مکانیزم: asyncio.create_task()، task.cancel()، task.result().
• کنترل: کنترل بیشتر بر اجرای coroutine‌ها، شامل لغو کردن و بازیابی نتیجه.
• سطح انتزاع: سطح بالاتر، راهی راحت برای مدیریت عملیات همزمان فراهم می‌کند.

چه زمانی از Coroutine‌ها به طور مستقیم و چه زمانی از Task‌ها استفاده کنیم:

در بسیاری از موارد، می‌توانید از coroutine‌ها به طور مستقیم و بدون ایجاد task استفاده کنید. با این حال، task‌ها زمانی ضروری هستند که شما نیاز به موارد زیر داشته باشید:

• اجرای چندین coroutine به صورت همزمان.
• لغو کردن یک coroutine در حال اجرا.
• بازیابی نتیجه یک coroutine.
• مدیریت استثناهای ایجاد شده توسط یک coroutine.

مثال‌های عملی از AsyncIO در عمل

بیایید چند مثال عملی از نحوه استفاده از asyncio برای ساخت برنامه‌های غیرهمزمان را بررسی کنیم.

مثال ۱: درخواست‌های وب همزمان

این مثال نشان می‌دهد چگونه می‌توان با استفاده از asyncio و کتابخانه aiohttp چندین درخواست وب را به صورت همزمان ارسال کرد:

import asyncio
import aiohttp

async def fetch_url(url):
  async with aiohttp.ClientSession() as session:
    async with session.get(url) as response:
      return await response.text()

async def main():
  urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
  ]

  tasks = [asyncio.create_task(fetch_url(url)) for url in urls]
  results = await asyncio.gather(*tasks)

  for i, result in enumerate(results):
    print(f"Result from {urls[i]}: {result[:100]}...")  # Print first 100 characters

asyncio.run(main())

این کد لیستی از task‌ها ایجاد می‌کند که هر کدام مسئول دریافت محتوای یک URL متفاوت هستند. تابع asyncio.gather() منتظر می‌ماند تا تمام task‌ها کامل شوند و لیستی از نتایج آن‌ها را برمی‌گرداند. این به شما امکان می‌دهد چندین صفحه وب را به صورت همزمان دریافت کنید و به طور قابل توجهی عملکرد را در مقایسه با ارسال درخواست‌ها به صورت متوالی بهبود بخشید.

مثال ۲: پردازش داده غیرهمزمان

این مثال نشان می‌دهد چگونه می‌توان یک مجموعه داده بزرگ را به صورت غیرهمزمان با استفاده از asyncio پردازش کرد:

import asyncio
import random

async def process_data(data):
  await asyncio.sleep(random.random())  # Simulate processing time
  return data * 2

async def main():
  data = list(range(100))
  tasks = [asyncio.create_task(process_data(item)) for item in data]
  results = await asyncio.gather(*tasks)

  print(f"Processed data: {results}")

asyncio.run(main())

این کد لیستی از task‌ها ایجاد می‌کند که هر کدام مسئول پردازش یک آیتم متفاوت در مجموعه داده هستند. تابع asyncio.gather() منتظر می‌ماند تا تمام task‌ها کامل شوند و لیستی از نتایج آن‌ها را برمی‌گرداند. این به شما امکان می‌دهد یک مجموعه داده بزرگ را به صورت همزمان پردازش کنید، از هسته‌های چندگانه CPU بهره‌مند شوید و زمان کلی پردازش را کاهش دهید.

بهترین شیوه‌ها برای برنامه‌نویسی با AsyncIO

برای نوشتن کد asyncio کارآمد و قابل نگهداری، این بهترین شیوه‌ها را دنبال کنید:

• فقط بر روی اشیاء awaitable از await استفاده کنید: اطمینان حاصل کنید که کلمه کلیدی await را فقط بر روی coroutine‌ها یا سایر اشیاء awaitable استفاده می‌کنید.
• از عملیات مسدودکننده در coroutine‌ها خودداری کنید: عملیات مسدودکننده، مانند I/O همزمان یا وظایف وابسته به CPU، می‌توانند حلقه رویداد را مسدود کرده و از اجرای coroutine‌های دیگر جلوگیری کنند. از جایگزین‌های غیرهمزمان استفاده کنید یا عملیات مسدودکننده را به یک رشته یا فرآیند جداگانه منتقل کنید.
• استثناها را به درستی مدیریت کنید: از بلوک‌های try...except برای مدیریت استثناهای ایجاد شده توسط coroutine‌ها و task‌ها استفاده کنید. این کار از کرش کردن برنامه شما توسط استثناهای مدیریت‌نشده جلوگیری می‌کند.
• Task‌هایی که دیگر مورد نیاز نیستند را لغو کنید: لغو کردن task‌هایی که دیگر لازم نیستند می‌تواند منابع را آزاد کرده و از محاسبات غیرضروری جلوگیری کند.
• از کتابخانه‌های غیرهمزمان استفاده کنید: برای عملیات I/O از کتابخانه‌های غیرهمزمان مانند aiohttp برای درخواست‌های وب و asyncpg برای دسترسی به پایگاه داده استفاده کنید.
• کد خود را پروفایل کنید: از ابزارهای پروفایلینگ برای شناسایی گلوگاه‌های عملکرد در کد asyncio خود استفاده کنید. این به شما کمک می‌کند تا کد خود را برای حداکثر کارایی بهینه‌سازی کنید.

مفاهیم پیشرفته AsyncIO

فراتر از اصول اولیه زمان‌بندی coroutine و مدیریت task، asyncio مجموعه‌ای از ویژگی‌های پیشرفته را برای ساخت برنامه‌های غیرهمزمان پیچیده ارائه می‌دهد.

صف‌های غیرهمزمان:

asyncio.Queue یک صف غیرهمزمان و ایمن برای thread (thread-safe) برای انتقال داده بین coroutine‌ها فراهم می‌کند. این می‌تواند برای پیاده‌سازی الگوهای تولیدکننده-مصرف‌کننده یا برای هماهنگی اجرای چندین task مفید باشد.

اولیه های همگام‌سازی غیرهمزمان:

asyncio نسخه‌های غیرهمزمان از اولیه های همگام‌سازی رایج مانند قفل‌ها (locks)، سمافورها (semaphores) و رویدادها (events) را فراهم می‌کند. این اولیه ها می‌توانند برای هماهنگی دسترسی به منابع مشترک در کد غیرهمزمان استفاده شوند.

حلقه‌های رویداد سفارشی:

در حالی که asyncio یک حلقه رویداد پیش‌فرض ارائه می‌دهد، شما همچنین می‌توانید حلقه‌های رویداد سفارشی را متناسب با نیازهای خاص خود ایجاد کنید. این می‌تواند برای ادغام asyncio با سایر چارچوب‌های رویدادمحور یا برای پیاده‌سازی الگوریتم‌های زمان‌بندی سفارشی مفید باشد.

AsyncIO در کشورها و صنایع مختلف

مزایای asyncio جهانی هستند و آن را در کشورها و صنایع مختلف قابل استفاده می‌کنند. این مثال‌ها را در نظر بگیرید:

• **تجارت الکترونیک (جهانی):** مدیریت درخواست‌های همزمان متعدد کاربران در فصول اوج خرید.
• **مالی (نیویورک، لندن، توکیو):** پردازش داده‌های معاملات با فرکانس بالا و مدیریت به‌روزرسانی‌های لحظه‌ای بازار.
• **بازی‌سازی (سئول، لس‌آنجلس):** ساخت سرورهای بازی مقیاس‌پذیر که می‌توانند هزاران بازیکن همزمان را مدیریت کنند.
• **اینترنت اشیاء (شنژن، سیلیکون ولی):** مدیریت جریان‌های داده از هزاران دستگاه متصل.
• **محاسبات علمی (ژنو، بوستون):** اجرای شبیه‌سازی‌ها و پردازش مجموعه داده‌های بزرگ به صورت همزمان.

نتیجه‌گیری

asyncio یک چارچوب قدرتمند و انعطاف‌پذیر برای ساخت برنامه‌های غیرهمزمان در پایتون فراهم می‌کند. درک مفاهیم زمان‌بندی coroutine و مدیریت task برای نوشتن کد غیرهمزمان کارآمد و مقیاس‌پذیر ضروری است. با پیروی از بهترین شیوه‌های ذکر شده در این پست وبلاگ، می‌توانید از قدرت asyncio برای ساخت برنامه‌های با کارایی بالا که می‌توانند چندین وظیفه را به صورت همزمان مدیریت کنند، بهره‌مند شوید.

همچنان که عمیق‌تر به برنامه‌نویسی غیرهمزمان با asyncio می‌پردازید، به یاد داشته باشید که برنامه‌ریزی دقیق و درک ظرافت‌های حلقه رویداد، کلید ساخت برنامه‌های قوی و مقیاس‌پذیر است. قدرت همزمانی را در آغوش بگیرید و پتانسیل کامل کد پایتون خود را آزاد کنید!