صف های Asyncio پایتون: تسلط بر الگوهای همزمان تولیدکننده-مصرف‌کننده

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

درک الگوی تولیدکننده-مصرف‌کننده

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

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

معرفی صف های Asyncio

کتابخانه asyncio یک پیاده‌سازی صف ناهمزمان (asyncio.Queue) ارائه می‌دهد که به طور خاص برای استفاده با کوروتین‌ها طراحی شده است. برخلاف صف‌های سنتی، asyncio.Queue از عملیات ناهمزمان (await) برای قرار دادن آیتم‌ها در صف و گرفتن آیتم‌ها از صف استفاده می‌کند، که به کوروتین‌ها اجازه می‌دهد تا در حالی که منتظر در دسترس قرار گرفتن صف هستند، کنترل را به حلقه رویداد واگذار کنند. این رفتار غیر مسدود کننده برای دستیابی به همزمانی واقعی در برنامه‌های asyncio ضروری است.

روش‌های کلیدی صف های Asyncio

در اینجا برخی از مهمترین روش‌ها برای کار با asyncio.Queue آورده شده است:

• put(item): یک آیتم را به صف اضافه می‌کند. اگر صف پر باشد (یعنی به حداکثر اندازه خود رسیده باشد)، کوروتین تا زمانی که فضایی در دسترس قرار گیرد، مسدود می‌شود. از await برای اطمینان از تکمیل عملیات به صورت ناهمزمان استفاده کنید: await queue.put(item).
• get(): یک آیتم را از صف حذف و برمی‌گرداند. اگر صف خالی باشد، کوروتین تا زمانی که یک آیتم در دسترس قرار گیرد، مسدود می‌شود. از await برای اطمینان از تکمیل عملیات به صورت ناهمزمان استفاده کنید: await queue.get().
• empty(): اگر صف خالی باشد True را برمی‌گرداند. در غیر این صورت، False را برمی‌گرداند. توجه داشته باشید که این یک شاخص قابل اعتماد از خالی بودن در یک محیط همزمان نیست، زیرا ممکن است یک وظیفه دیگر بین فراخوانی empty() و استفاده از آن، یک آیتم را اضافه یا حذف کند.
• full(): اگر صف پر باشد True را برمی‌گرداند. در غیر این صورت، False را برمی‌گرداند. مشابه empty()، این یک شاخص قابل اعتماد از پر بودن در یک محیط همزمان نیست.
• qsize(): تعداد تقریبی آیتم‌ها را در صف برمی‌گرداند. شمارش دقیق ممکن است به دلیل عملیات همزمان کمی قدیمی باشد.
• join(): تا زمانی که همه آیتم‌ها در صف گرفته و پردازش شوند، مسدود می‌شود. این معمولاً توسط مصرف‌کننده استفاده می‌شود تا نشان دهد که پردازش همه آیتم‌ها را به پایان رسانده است. تولیدکنندگان پس از پردازش یک آیتم گرفته شده، queue.task_done() را فراخوانی می‌کنند.
• task_done(): نشان می‌دهد که یک وظیفه قبلاً در صف قرار گرفته، کامل شده است. توسط مصرف کنندگان صف استفاده می‌شود. برای هر get()، یک فراخوانی بعدی به task_done() به صف می‌گوید که پردازش وظیفه کامل شده است.

پیاده‌سازی یک مثال اساسی تولیدکننده-مصرف‌کننده

بیایید استفاده از asyncio.Queue را با یک مثال ساده تولیدکننده-مصرف‌کننده نشان دهیم. ما یک تولیدکننده را شبیه‌سازی خواهیم کرد که اعداد تصادفی تولید می‌کند و یک مصرف‌کننده که آن اعداد را به توان دو می‌رساند.

```python import asyncio import random async def producer(queue: asyncio.Queue, n: int): for _ in range(n): # Simulate some work await asyncio.sleep(random.random()) value = random.randint(1, 100) print(f"Producer: Adding {value} to the queue") await queue.put(value) # Signal the consumer that no more items will be added for _ in range(3): # Number of consumers await queue.put(None) async def consumer(queue: asyncio.Queue, id: int): while True: value = await queue.get() if value is None: print(f"Consumer {id}: Exiting.") queue.task_done() break # Simulate some work await asyncio.sleep(random.random()) result = value * value print(f"Consumer {id}: Consumed {value}, Result: {result}") queue.task_done() async def main(): queue = asyncio.Queue() num_producers = 1 num_consumers = 3 total_items = 10 producers = [asyncio.create_task(producer(queue, total_items // num_producers)) for _ in range(num_producers)] consumers = [asyncio.create_task(consumer(queue, id)) for id in range(num_consumers)] await asyncio.gather(*producers) await queue.join() # Wait for all items to be processed await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

در این مثال:

• تابع producer اعداد تصادفی تولید می‌کند و آنها را به صف اضافه می‌کند. پس از تولید همه اعداد، None را به صف اضافه می‌کند تا به مصرف‌کننده علامت دهد که کارش تمام شده است.
• تابع consumer اعداد را از صف بازیابی می‌کند، آنها را به توان دو می‌رساند و نتیجه را چاپ می‌کند. تا زمانی که سیگنال None را دریافت نکند، ادامه می‌دهد.
• تابع main یک asyncio.Queue ایجاد می‌کند، وظایف تولیدکننده و مصرف‌کننده را شروع می‌کند و با استفاده از asyncio.gather منتظر می‌ماند تا آنها کامل شوند.
• مهم: پس از پردازش یک آیتم توسط یک مصرف کننده، queue.task_done() را فراخوانی می‌کند. فراخوانی queue.join() در `main()` تا زمانی که همه آیتم‌ها در صف پردازش شوند، مسدود می‌شود (یعنی تا زمانی که برای هر آیتمی که در صف قرار داده شده است، task_done() فراخوانی نشده باشد).
• ما از `asyncio.gather(*consumers)` استفاده می‌کنیم تا اطمینان حاصل کنیم که همه مصرف‌کنندگان قبل از خروج تابع `main()` به پایان می‌رسند. این به ویژه هنگام علامت دادن به مصرف‌کنندگان برای خروج با استفاده از `None` مهم است.

الگوهای پیشرفته تولیدکننده-مصرف‌کننده

مثال اساسی را می‌توان برای رسیدگی به سناریوهای پیچیده‌تر گسترش داد. در اینجا برخی از الگوهای پیشرفته آورده شده است:

تولیدکنندگان و مصرف‌کنندگان متعدد

شما به راحتی می‌توانید تولیدکنندگان و مصرف‌کنندگان متعددی ایجاد کنید تا همزمانی را افزایش دهید. صف به عنوان یک نقطه مرکزی ارتباط عمل می‌کند و کار را به طور مساوی بین مصرف‌کنندگان توزیع می‌کند.

```python import asyncio import random async def producer(queue: asyncio.Queue, producer_id: int, num_items: int): for i in range(num_items): await asyncio.sleep(random.random() * 0.5) # Simulate some work item = (producer_id, i) print(f"Producer {producer_id}: Producing item {item}") await queue.put(item) print(f"Producer {producer_id}: Finished producing.") # Don't signal consumers here; handle it in main async def consumer(queue: asyncio.Queue, consumer_id: int): while True: item = await queue.get() if item is None: print(f"Consumer {consumer_id}: Exiting.") queue.task_done() break producer_id, item_id = item await asyncio.sleep(random.random() * 0.5) # Simulate processing time print(f"Consumer {consumer_id}: Consuming item {item} from Producer {producer_id}") queue.task_done() async def main(): queue = asyncio.Queue() num_producers = 3 num_consumers = 5 items_per_producer = 10 producers = [asyncio.create_task(producer(queue, i, items_per_producer)) for i in range(num_producers)] consumers = [asyncio.create_task(consumer(queue, i)) for i in range(num_consumers)] await asyncio.gather(*producers) # Signal the consumers to exit after all producers have finished. for _ in range(num_consumers): await queue.put(None) await queue.join() await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

در این مثال اصلاح شده، ما چندین تولیدکننده و چندین مصرف‌کننده داریم. به هر تولیدکننده یک شناسه منحصر به فرد اختصاص داده شده است، و هر مصرف‌کننده آیتم‌ها را از صف بازیابی می‌کند و آنها را پردازش می‌کند. مقدار نگهبان None پس از اتمام کار همه تولیدکنندگان به صف اضافه می‌شود و به مصرف‌کنندگان سیگنال می‌دهد که کار دیگری وجود نخواهد داشت. مهمتر از همه، ما قبل از خروج queue.join() را فراخوانی می‌کنیم. مصرف کننده پس از پردازش یک مورد queue.task_done() را فراخوانی می‌کند.

رسیدگی به استثناها

در برنامه‌های کاربردی دنیای واقعی، باید استثناهایی را که ممکن است در طول فرآیند تولید یا مصرف رخ دهند، مدیریت کنید. می‌توانید از بلوک‌های try...except در کوروتین‌های تولیدکننده و مصرف‌کننده خود برای گرفتن و مدیریت استثناها به صورت ظریف استفاده کنید.

```python import asyncio import random async def producer(queue: asyncio.Queue, producer_id: int, num_items: int): for i in range(num_items): try: await asyncio.sleep(random.random() * 0.5) # Simulate some work if random.random() < 0.1: # Simulate an error raise Exception(f"Producer {producer_id}: Simulated error!") item = (producer_id, i) print(f"Producer {producer_id}: Producing item {item}") await queue.put(item) except Exception as e: print(f"Producer {producer_id}: Error producing item: {e}") # Optionally, put a special error item on the queue # await queue.put(('ERROR', str(e))) print(f"Producer {producer_id}: Finished producing.") async def consumer(queue: asyncio.Queue, consumer_id: int): while True: item = await queue.get() if item is None: print(f"Consumer {consumer_id}: Exiting.") queue.task_done() break try: producer_id, item_id = item await asyncio.sleep(random.random() * 0.5) # Simulate processing time if random.random() < 0.05: # Simulate error during consumption raise ValueError(f"Consumer {consumer_id}: Invalid item! ") print(f"Consumer {consumer_id}: Consuming item {item} from Producer {producer_id}") except Exception as e: print(f"Consumer {consumer_id}: Error consuming item: {e}") finally: queue.task_done() async def main(): queue = asyncio.Queue() num_producers = 3 num_consumers = 5 items_per_producer = 10 producers = [asyncio.create_task(producer(queue, i, items_per_producer)) for i in range(num_producers)] consumers = [asyncio.create_task(consumer(queue, i)) for i in range(num_consumers)] await asyncio.gather(*producers) # Signal the consumers to exit after all producers have finished. for _ in range(num_consumers): await queue.put(None) await queue.join() await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

در این مثال، خطاهای شبیه‌سازی شده را هم در تولیدکننده و هم در مصرف‌کننده معرفی می‌کنیم. بلوک‌های try...except این خطاها را می‌گیرند و به وظایف اجازه می‌دهند پردازش سایر آیتم‌ها را ادامه دهند. مصرف کننده همچنان queue.task_done() را در بلوک finally فراخوانی می‌کند تا اطمینان حاصل شود که شمارنده داخلی صف حتی در صورت وقوع استثنا به درستی به روز می‌شود.

وظایف اولویت‌بندی شده

گاهی اوقات، ممکن است لازم باشد وظایف خاصی را بر سایر وظایف اولویت دهید. asyncio مستقیماً یک صف اولویت را ارائه نمی‌دهد، اما می‌توانید به راحتی با استفاده از ماژول heapq یک صف را پیاده‌سازی کنید.

```python import asyncio import heapq import random class PriorityQueue: def __init__(self): self._queue = [] self._count = 0 self._condition = asyncio.Condition(asyncio.Lock()) async def put(self, item, priority): async with self._condition: heapq.heappush(self._queue, (priority, self._count, item)) self._count += 1 self._condition.notify_all() async def get(self): async with self._condition: while not self._queue: await self._condition.wait() priority, count, item = heapq.heappop(self._queue) return item def qsize(self): return len(self._queue) def empty(self): return not self._queue async def producer(queue: PriorityQueue, producer_id: int, num_items: int): for i in range(num_items): await asyncio.sleep(random.random() * 0.5) # Simulate some work priority = random.randint(1, 10) # Assign a random priority item = (producer_id, i) print(f"Producer {producer_id}: Producing item {item} with priority {priority}") await queue.put(item, priority) print(f"Producer {producer_id}: Finished producing.") async def consumer(queue: PriorityQueue, consumer_id: int): while True: item = await queue.get() if item is None: print(f"Consumer {consumer_id}: Exiting.") break producer_id, item_id = item await asyncio.sleep(random.random() * 0.5) # Simulate processing time print(f"Consumer {consumer_id}: Consuming item {item} from Producer {producer_id}") async def main(): queue = PriorityQueue() num_producers = 2 num_consumers = 3 items_per_producer = 5 producers = [asyncio.create_task(producer(queue, i, items_per_producer)) for i in range(num_producers)] consumers = [asyncio.create_task(consumer(queue, i)) for i in range(num_consumers)] await asyncio.gather(*producers) # Signal consumers to exit (not needed for this example). # for _ in range(num_consumers): # await queue.put(None, 0) await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

این مثال یک کلاس PriorityQueue را تعریف می‌کند که از heapq برای نگهداری یک صف مرتب شده بر اساس اولویت استفاده می‌کند. آیتم‌هایی با مقادیر اولویت پایین‌تر ابتدا پردازش می‌شوند. توجه داشته باشید که ما دیگر از `queue.join()` و `queue.task_done()` استفاده نمی‌کنیم. از آنجایی که ما یک راه داخلی برای ردیابی تکمیل وظایف در این مثال صف اولویت نداریم، مصرف کننده به طور خودکار از آن خارج نمی‌شود، بنابراین در صورت نیاز به توقف، باید راهی برای علامت دادن به مصرف کنندگان برای خروج پیاده‌سازی شود. اگر queue.join() و queue.task_done() حیاتی هستند، ممکن است لازم باشد کلاس PriorityQueue سفارشی را برای پشتیبانی از عملکرد مشابه گسترش دهید یا تطبیق دهید.

زمان‌بندی و لغو

در برخی موارد، ممکن است بخواهید یک زمان‌بندی برای گرفتن یا قرار دادن آیتم‌ها در صف تنظیم کنید. می‌توانید از asyncio.wait_for برای دستیابی به این هدف استفاده کنید.

```python import asyncio async def consumer(queue: asyncio.Queue): while True: try: item = await asyncio.wait_for(queue.get(), timeout=5.0) # Timeout after 5 seconds print(f"Consumer: Consumed {item}") queue.task_done() except asyncio.TimeoutError: print("Consumer: Timeout waiting for item") break except asyncio.CancelledError: print("Consumer: Cancelled") break async def main(): queue = asyncio.Queue() consumer_task = asyncio.create_task(consumer(queue)) await asyncio.sleep(10) # Give the consumer some time print("Producer: Cancelling consumer") consumer_task.cancel() try: await consumer_task # Await the cancelled task to handle exceptions except asyncio.CancelledError: print("Main: Consumer task cancelled successfully.") if __name__ == "__main__": asyncio.run(main()) ```

در این مثال، مصرف کننده حداکثر 5 ثانیه منتظر می‌ماند تا یک آیتم در صف در دسترس قرار گیرد. اگر هیچ آیتمی در مدت زمان‌بندی در دسترس نباشد، یک asyncio.TimeoutError را افزایش می‌دهد. همچنین می‌توانید وظیفه مصرف کننده را با استفاده از task.cancel() لغو کنید.

بهترین روش‌ها و ملاحظات

• اندازه صف: اندازه صف مناسب را بر اساس حجم کاری مورد انتظار و حافظه موجود انتخاب کنید. یک صف کوچک ممکن است منجر به مسدود شدن مکرر تولیدکنندگان شود، در حالی که یک صف بزرگ ممکن است حافظه بیش از حد مصرف کند. برای یافتن اندازه بهینه برای برنامه خود آزمایش کنید. یک الگوی ضد رایج ایجاد یک صف نامحدود است.
• مدیریت خطا: مدیریت خطای قوی را برای جلوگیری از خرابی برنامه خود به دلیل استثناها پیاده‌سازی کنید. از بلوک‌های try...except برای گرفتن و مدیریت استثناها در وظایف تولیدکننده و مصرف‌کننده استفاده کنید.
• جلوگیری از بن‌بست: هنگام استفاده از چندین صف یا سایر عناصر همگام‌سازی، مراقب باشید تا از بن‌بست جلوگیری کنید. اطمینان حاصل کنید که وظایف منابع را به ترتیب سازگار آزاد می‌کنند تا از وابستگی‌های دایره‌ای جلوگیری شود. اطمینان حاصل کنید که اتمام کار با استفاده از queue.join() و queue.task_done() در صورت نیاز انجام می‌شود.
• علامت دادن به اتمام: از یک مکانیسم قابل اعتماد برای علامت دادن به اتمام به مصرف کنندگان، مانند یک مقدار نگهبان (به عنوان مثال، None) یا یک پرچم مشترک استفاده کنید. اطمینان حاصل کنید که همه مصرف‌کنندگان در نهایت سیگنال را دریافت می‌کنند و با ظرافت خارج می‌شوند. خروج مصرف‌کننده را به درستی برای خاموش شدن تمیز برنامه علامت دهید.
• مدیریت زمینه: زمینه های وظیفه asyncio را با استفاده از عبارات `async with` به درستی برای منابعی مانند فایل‌ها یا اتصالات پایگاه داده مدیریت کنید تا از پاکسازی مناسب، حتی در صورت بروز خطا، اطمینان حاصل شود.
• نظارت: برای شناسایی تنگناها بالقوه و بهینه‌سازی عملکرد، اندازه صف، توان عملیاتی تولیدکننده و تأخیر مصرف‌کننده را نظارت کنید. ثبت اطلاعات می‌تواند برای رفع اشکال مشکلات مفید باشد.
• اجتناب از عملیات مسدود کننده: هرگز عملیات مسدود کننده (به عنوان مثال، ورودی/خروجی همزمان، محاسبات طولانی مدت) را مستقیماً در کوروتین‌های خود انجام ندهید. از asyncio.to_thread() یا یک استخر فرآیند برای تخلیه عملیات مسدود کننده به یک رشته یا فرآیند جداگانه استفاده کنید.

برنامه‌های کاربردی دنیای واقعی

الگوی تولیدکننده-مصرف‌کننده با صف‌های asyncio برای طیف گسترده‌ای از سناریوهای دنیای واقعی قابل استفاده است:

• وب اسکرپرها: تولیدکنندگان صفحات وب را واکشی می‌کنند و مصرف‌کنندگان داده‌ها را تجزیه و استخراج می‌کنند.
• پردازش تصویر/ویدئو: تولیدکنندگان تصاویر/ویدئوها را از دیسک یا شبکه می‌خوانند و مصرف‌کنندگان عملیات پردازشی را انجام می‌دهند (به عنوان مثال، تغییر اندازه، فیلتر کردن).
• خطوط لوله داده: تولیدکنندگان داده‌ها را از منابع مختلف جمع‌آوری می‌کنند (به عنوان مثال، حسگرها، APIها) و مصرف‌کنندگان داده‌ها را تبدیل و در یک پایگاه داده یا انبار داده بارگیری می‌کنند.
• صف‌های پیام: صف‌های asyncio می‌توانند به عنوان یک بلوک ساختمانی برای پیاده‌سازی سیستم‌های صف پیام سفارشی استفاده شوند.
• پردازش وظایف پس‌زمینه در برنامه‌های کاربردی وب: تولیدکنندگان درخواست‌های HTTP را دریافت می‌کنند و وظایف پس‌زمینه را در صف قرار می‌دهند و مصرف‌کنندگان آن وظایف را به صورت ناهمزمان پردازش می‌کنند. این از مسدود شدن برنامه کاربردی وب اصلی در عملیات طولانی مدت مانند ارسال ایمیل یا پردازش داده‌ها جلوگیری می‌کند.
• سیستم‌های معاملاتی مالی: تولیدکنندگان فیدهای داده بازار را دریافت می‌کنند و مصرف‌کنندگان داده‌ها را تجزیه و تحلیل می‌کنند و معاملات را اجرا می‌کنند. ماهیت ناهمزمان asyncio امکان زمان‌های پاسخ تقریباً هم‌زمان و مدیریت حجم بالای داده را فراهم می‌کند.
• پردازش داده‌های اینترنت اشیا: تولیدکنندگان داده‌ها را از دستگاه‌های اینترنت اشیا جمع‌آوری می‌کنند و مصرف‌کنندگان داده‌ها را در زمان واقعی پردازش و تجزیه و تحلیل می‌کنند. Asyncio سیستم را قادر می‌سازد تا تعداد زیادی اتصال همزمان از دستگاه‌های مختلف را مدیریت کند و آن را برای برنامه‌های کاربردی اینترنت اشیا مناسب می‌سازد.

جایگزین‌های صف های Asyncio

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

• صف‌های پردازش چندگانه: اگر نیاز دارید عملیات محدود به CPU را انجام دهید که نمی‌توان آنها را به طور کارآمد با استفاده از رشته‌ها موازی کرد (به دلیل قفل مفسر جهانی - GIL)، از multiprocessing.Queue استفاده کنید. این به شما امکان می‌دهد تولیدکنندگان و مصرف‌کنندگان را در فرآیندهای جداگانه اجرا کنید و GIL را دور بزنید. با این حال، توجه داشته باشید که ارتباط بین فرآیندها عموماً گران‌تر از ارتباط بین رشته‌ها است.
• صف‌های پیام شخص ثالث (به عنوان مثال، RabbitMQ، Kafka): برای برنامه‌های پیچیده‌تر و توزیع شده، از یک سیستم صف پیام اختصاصی مانند RabbitMQ یا Kafka استفاده کنید. این سیستم‌ها ویژگی‌های پیشرفته‌ای مانند مسیریابی پیام، پایداری و مقیاس‌پذیری را ارائه می‌دهند.
• کانال‌ها (به عنوان مثال، Trio): کتابخانه Trio کانال‌هایی را ارائه می‌دهد که در مقایسه با صف‌ها، روشی ساختارمندتر و قابل ترکیب برای ارتباط بین وظایف همزمان ارائه می‌دهند.
• aiormq (مشتری RabbitMQ ناهمزمان): اگر به طور خاص به یک رابط ناهمزمان به RabbitMQ نیاز دارید، کتابخانه aiormq یک انتخاب عالی است.

نتیجه‌گیری

صف‌های asyncio یک مکانیزم قوی و کارآمد برای پیاده‌سازی الگوهای همزمان تولیدکننده-مصرف‌کننده در پایتون ارائه می‌دهند. با درک مفاهیم کلیدی و بهترین روش‌های بحث شده در این راهنما، می‌توانید از صف‌های asyncio برای ساخت برنامه‌های کاربردی با کارایی بالا، مقیاس‌پذیر و پاسخگو استفاده کنید. برای یافتن راه حل بهینه برای نیازهای خاص خود، با اندازه‌های مختلف صف، استراتژی‌های مدیریت خطا و الگوهای پیشرفته آزمایش کنید. پذیرش برنامه‌نویسی ناهمزمان با asyncio و صف‌ها به شما این امکان را می‌دهد که برنامه‌هایی ایجاد کنید که می‌توانند حجم‌های کاری سنگین را مدیریت کنند و تجربیات کاربری استثنایی را ارائه دهند.