പൈത്തൺ അസിൻക്യോ ക്യൂസ്: കൺകറൻ്റ് പ്രൊഡ്യൂസർ-കൺസ്യൂമർ പാറ്റേണുകളിൽ വൈദഗ്ദ്ധ്യം നേടാം

ഉയർന്ന പ്രകടനവും സ്കേലബിലിറ്റിയുമുള്ള ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിന് അസിൻക്രണസ് പ്രോഗ്രാമിംഗ് വളരെ പ്രധാനമായി മാറിയിരിക്കുന്നു. പൈത്തണിൻ്റെ asyncio ലൈബ്രറി കോറൂട്ടീനുകളും ഇവൻ്റ് ലൂപ്പുകളും ഉപയോഗിച്ച് കൺകറൻസി കൈവരിക്കുന്നതിന് ശക്തമായ ഒരു ചട്ടക്കൂട് നൽകുന്നു. asyncio നൽകുന്ന നിരവധി ടൂളുകളിൽ, ഒരേ സമയം പ്രവർത്തിക്കുന്ന ടാസ്ക്കുകൾക്കിടയിൽ ആശയവിനിമയത്തിനും ഡാറ്റ പങ്കിടലിനും ക്യൂകൾ ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു, പ്രത്യേകിച്ചും പ്രൊഡ്യൂസർ-കൺസ്യൂമർ പാറ്റേണുകൾ നടപ്പിലാക്കുമ്പോൾ.

പ്രൊഡ്യൂസർ-കൺസ്യൂമർ പാറ്റേൺ മനസ്സിലാക്കാം

പ്രൊഡ്യൂസർ-കൺസ്യൂമർ പാറ്റേൺ കൺകറൻ്റ് പ്രോഗ്രാമിംഗിലെ ഒരു അടിസ്ഥാന ഡിസൈൻ പാറ്റേണാണ്. ഇതിൽ രണ്ടോ അതിലധികമോ തരം പ്രോസസ്സുകളോ ത്രെഡുകളോ ഉൾപ്പെടുന്നു: ഡാറ്റയോ ടാസ്ക്കുകളോ ഉണ്ടാക്കുന്ന പ്രൊഡ്യൂസർമാരും, ആ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുകയോ ഉപയോഗിക്കുകയോ ചെയ്യുന്ന കൺസ്യൂമർമാരും. ഒരു ഷെയർഡ് ബഫർ, സാധാരണയായി ഒരു ക്യൂ, ഒരു ഇടനിലക്കാരനായി പ്രവർത്തിക്കുന്നു, ഇത് പ്രൊഡ്യൂസർമാർക്ക് കൺസ്യൂമർമാരെ ബുദ്ധിമുട്ടിക്കാതെ ഐറ്റംസ് ചേർക്കാൻ അനുവദിക്കുകയും, വേഗത കുറഞ്ഞ പ്രൊഡ്യൂസർമാർ കാരണം ബ്ലോക്ക് ആവാതെ കൺസ്യൂമർമാർക്ക് സ്വതന്ത്രമായി പ്രവർത്തിക്കാൻ സഹായിക്കുകയും ചെയ്യുന്നു. ഈ വേർതിരിക്കൽ കൺകറൻസി, റെസ്പോൺസീവ്നസ്, സിസ്റ്റത്തിന്റെ മൊത്തത്തിലുള്ള കാര്യക്ഷമത എന്നിവ വർദ്ധിപ്പിക്കുന്നു.

നിങ്ങളൊരു വെബ് സ്ക്രാപ്പർ നിർമ്മിക്കുകയാണെന്ന് കരുതുക. പ്രൊഡ്യൂസർമാർ ഇൻ്റർനെറ്റിൽ നിന്ന് URL-കൾ ശേഖരിക്കുന്ന ടാസ്ക്കുകളാകാം, കൺസ്യൂമർമാർ HTML ഉള്ളടക്കം പാഴ്സ് ചെയ്ത് ആവശ്യമായ വിവരങ്ങൾ വേർതിരിച്ചെടുക്കുന്ന ടാസ്ക്കുകളാകാം. ഒരു ക്യൂ ഇല്ലെങ്കിൽ, അടുത്ത URL എടുക്കുന്നതിന് മുമ്പ് കൺസ്യൂമർ പ്രോസസ്സിംഗ് പൂർത്തിയാക്കാൻ പ്രൊഡ്യൂസർക്ക് കാത്തിരിക്കേണ്ടി വന്നേക്കാം, അല്ലെങ്കിൽ തിരിച്ചും. ഒരു ക്യൂ ഈ ടാസ്ക്കുകളെ ഒരേ സമയം പ്രവർത്തിപ്പിക്കാൻ സഹായിക്കുന്നു, അതുവഴി ത്രൂപുട്ട് പരമാവധിയാക്കുന്നു.

അസിൻക്യോ ക്യൂസിനെ പരിചയപ്പെടാം

asyncio ലൈബ്രറി കോറൂട്ടീനുകൾക്കൊപ്പം ഉപയോഗിക്കാൻ പ്രത്യേകം രൂപകൽപ്പന ചെയ്ത ഒരു അസിൻക്രണസ് ക്യൂ ഇംപ്ലിമെൻ്റേഷൻ (asyncio.Queue) നൽകുന്നു. പരമ്പരാഗത ക്യൂകളിൽ നിന്ന് വ്യത്യസ്തമായി, asyncio.Queue ക്യൂവിലേക്ക് ഐറ്റംസ് ഇടുന്നതിനും എടുക്കുന്നതിനും അസിൻക്രണസ് ഓപ്പറേഷനുകൾ (await) ഉപയോഗിക്കുന്നു, ഇത് ക്യൂ ലഭ്യമാകുന്നതുവരെ കാത്തിരിക്കുമ്പോൾ കോറൂട്ടീനുകൾക്ക് ഇവൻ്റ് ലൂപ്പിലേക്ക് നിയന്ത്രണം തിരികെ നൽകാൻ അനുവദിക്കുന്നു. 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): # കുറച്ച് ജോലി സിമുലേറ്റ് ചെയ്യുന്നു await asyncio.sleep(random.random()) value = random.randint(1, 100) print(f"Producer: Adding {value} to the queue") await queue.put(value) # കൂടുതൽ ഐറ്റംസ് ചേർക്കില്ലെന്ന് കൺസ്യൂമറെ അറിയിക്കുന്നു for _ in range(3): # കൺസ്യൂമർമാരുടെ എണ്ണം 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 # കുറച്ച് ജോലി സിമുലേറ്റ് ചെയ്യുന്നു 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() # എല്ലാ ഐറ്റംസും പ്രോസസ്സ് ചെയ്യാൻ കാത്തിരിക്കുക await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

ഈ ഉദാഹരണത്തിൽ:

• producer ഫംഗ്ഷൻ ക്രമരഹിതമായ സംഖ്യകൾ ഉണ്ടാക്കി ക്യൂവിലേക്ക് ചേർക്കുന്നു. എല്ലാ സംഖ്യകളും ഉണ്ടാക്കിയ ശേഷം, അത് പൂർത്തിയായി എന്ന് കൺസ്യൂമറെ അറിയിക്കാൻ ക്യൂവിലേക്ക് None ചേർക്കുന്നു.
• consumer ഫംഗ്ഷൻ ക്യൂവിൽ നിന്ന് സംഖ്യകൾ എടുത്ത്, അവയുടെ വർഗ്ഗം കണ്ട്, ഫലം പ്രിൻ്റ് ചെയ്യുന്നു. None സിഗ്നൽ ലഭിക്കുന്നതുവരെ ഇത് തുടരുന്നു.
• main ഫംഗ്ഷൻ ഒരു asyncio.Queue ഉണ്ടാക്കുകയും, പ്രൊഡ്യൂസർ, കൺസ്യൂമർ ടാസ്ക്കുകൾ ആരംഭിച്ച്, asyncio.gather ഉപയോഗിച്ച് അവ പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കുകയും ചെയ്യുന്നു.
• പ്രധാനപ്പെട്ടത്: ഒരു കൺസ്യൂമർ ഒരു ഐറ്റം പ്രോസസ്സ് ചെയ്ത ശേഷം, അത് queue.task_done() എന്ന് വിളിക്കുന്നു. `main()` ലെ queue.join() കോൾ ക്യൂവിലെ എല്ലാ ഐറ്റംസും പ്രോസസ്സ് ചെയ്യുന്നതുവരെ ബ്ലോക്ക് ചെയ്യുന്നു (അതായത്, ക്യൂവിലേക്ക് ചേർത്ത ഓരോ ഐറ്റത്തിനും task_done() വിളിക്കുന്നതുവരെ).
• `main()` ഫംഗ്ഷൻ അവസാനിക്കുന്നതിന് മുമ്പ് എല്ലാ കൺസ്യൂമർമാരും പൂർത്തിയാകുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഞങ്ങൾ asyncio.gather(*consumers) ഉപയോഗിക്കുന്നു. 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) # കുറച്ച് ജോലി സിമുലേറ്റ് ചെയ്യുന്നു item = (producer_id, i) print(f"Producer {producer_id}: Producing item {item}") await queue.put(item) print(f"Producer {producer_id}: Finished producing.") # ഇവിടെ കൺസ്യൂമർമാർക്ക് സിഗ്നൽ നൽകരുത്; അത് 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) # പ്രോസസ്സിംഗ് സമയം സിമുലേറ്റ് ചെയ്യുന്നു 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) # എല്ലാ പ്രൊഡ്യൂസർമാരും പൂർത്തിയായ ശേഷം കൺസ്യൂമർമാർക്ക് പുറത്തുകടക്കാൻ സിഗ്നൽ നൽകുന്നു. 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) # കുറച്ച് ജോലി സിമുലേറ്റ് ചെയ്യുന്നു if random.random() < 0.1: # ഒരു പിശക് സിമുലേറ്റ് ചെയ്യുന്നു 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}") # വേണമെങ്കിൽ, ക്യൂവിൽ ഒരു പ്രത്യേക എറർ ഐറ്റം ഇടുക # 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) # പ്രോസസ്സിംഗ് സമയം സിമുലേറ്റ് ചെയ്യുന്നു if random.random() < 0.05: # കൺസംപ്ഷൻ സമയത്ത് പിശക് സിമുലേറ്റ് ചെയ്യുന്നു 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) # എല്ലാ പ്രൊഡ്യൂസർമാരും പൂർത്തിയായ ശേഷം കൺസ്യൂമർമാർക്ക് പുറത്തുകടക്കാൻ സിഗ്നൽ നൽകുന്നു. for _ in range(num_consumers): await queue.put(None) await queue.join() await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

ഈ ഉദാഹരണത്തിൽ, പ്രൊഡ്യൂസറിലും കൺസ്യൂമറിലും സിമുലേറ്റഡ് പിശകുകൾ ഞങ്ങൾ അവതരിപ്പിക്കുന്നു. try...except ബ്ലോക്കുകൾ ഈ പിശകുകൾ പിടിച്ചെടുക്കുന്നു, ഇത് മറ്റ് ഐറ്റംസ് പ്രോസസ്സ് ചെയ്യുന്നത് തുടരാൻ ടാസ്ക്കുകളെ അനുവദിക്കുന്നു. എക്സെപ്ഷനുകൾ ഉണ്ടാകുമ്പോൾ പോലും ക്യൂവിൻ്റെ ഇൻ്റേണൽ കൗണ്ടർ ശരിയായി അപ്ഡേറ്റ് ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കാൻ കൺസ്യൂമർ finally ബ്ലോക്കിൽ queue.task_done() എന്ന് വിളിക്കുന്നു.

മുൻഗണനയുള്ള ടാസ്ക്കുകൾ

ചിലപ്പോൾ, നിങ്ങൾക്ക് ചില ടാസ്ക്കുകൾക്ക് മറ്റുള്ളവയേക്കാൾ മുൻഗണന നൽകേണ്ടി വന്നേക്കാം. 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) # കുറച്ച് ജോലി സിമുലേറ്റ് ചെയ്യുന്നു priority = random.randint(1, 10) # ഒരു റാൻഡം മുൻഗണന നൽകുന്നു 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) # പ്രോസസ്സിംഗ് സമയം സിമുലേറ്റ് ചെയ്യുന്നു 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) # കൺസ്യൂമർമാർക്ക് പുറത്തുകടക്കാൻ സിഗ്നൽ നൽകുക (ഈ ഉദാഹരണത്തിന് ആവശ്യമില്ല). # for _ in range(num_consumers): # await queue.put(None, 0) await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

ഈ ഉദാഹരണം മുൻഗണന അനുസരിച്ച് ഒരു സോർട്ടഡ് ക്യൂ നിലനിർത്താൻ heapq ഉപയോഗിക്കുന്ന ഒരു PriorityQueue ക്ലാസ് നിർവചിക്കുന്നു. കുറഞ്ഞ പ്രയോറിറ്റി മൂല്യമുള്ള ഐറ്റംസ് ആദ്യം പ്രോസസ്സ് ചെയ്യും. ഞങ്ങൾ ഇനി 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) # 5 സെക്കൻഡിന് ശേഷം ടൈംഔട്ട് 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) # കൺസ്യൂമർക്ക് കുറച്ച് സമയം നൽകുക print("Producer: Cancelling consumer") consumer_task.cancel() try: await consumer_task # എക്സെപ്ഷനുകൾ കൈകാര്യം ചെയ്യാൻ ക്യാൻസൽ ചെയ്ത ടാസ്ക്കിനായി കാത്തിരിക്കുക 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) അല്ലെങ്കിൽ ഒരു ഷെയർഡ് ഫ്ലാഗ് പോലുള്ള കൺസ്യൂമർമാർക്ക് പൂർത്തീകരണം സൂചിപ്പിക്കാൻ വിശ്വസനീയമായ ഒരു സംവിധാനം ഉപയോഗിക്കുക. എല്ലാ കൺസ്യൂമർമാർക്കും അവസാനം സിഗ്നൽ ലഭിക്കുകയും ഭംഗിയായി പുറത്തുകടക്കുകയും ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുക. ഒരു ക്ലീൻ ആപ്ലിക്കേഷൻ ഷട്ട്ഡൗണിനായി കൺസ്യൂമർ എക്സിറ്റ് ശരിയായി സിഗ്നൽ ചെയ്യുക.
• സന്ദർഭ മാനേജ്മെൻ്റ് (Context Management): പിശകുകൾ സംഭവിച്ചാൽ പോലും ശരിയായ ക്ലീനപ്പ് ഉറപ്പാക്കാൻ ഫയലുകൾ അല്ലെങ്കിൽ ഡാറ്റാബേസ് കണക്ഷനുകൾ പോലുള്ള റിസോഴ്സുകൾക്കായി async with സ്റ്റേറ്റ്മെൻ്റുകൾ ഉപയോഗിച്ച് അസിൻക്യോ ടാസ്ക് കോൺടെക്സ്റ്റുകൾ ശരിയായി കൈകാര്യം ചെയ്യുക.
• നിരീക്ഷണം: സാധ്യതയുള്ള തടസ്സങ്ങൾ തിരിച്ചറിയാനും പ്രകടനം ഒപ്റ്റിമൈസ് ചെയ്യാനും ക്യൂവിൻ്റെ വലുപ്പം, പ്രൊഡ്യൂസർ ത്രൂപുട്ട്, കൺസ്യൂമർ ലേറ്റൻസി എന്നിവ നിരീക്ഷിക്കുക. പ്രശ്നങ്ങൾ ഡീബഗ് ചെയ്യുന്നതിന് ലോഗിംഗ് സഹായകമാകും.
• ബ്ലോക്കിംഗ് ഓപ്പറേഷനുകൾ ഒഴിവാക്കുക: നിങ്ങളുടെ കോറൂട്ടീനുകൾക്കുള്ളിൽ നേരിട്ട് ബ്ലോക്കിംഗ് ഓപ്പറേഷനുകൾ (ഉദാ. സിൻക്രണസ് I/O, ദീർഘനേരം പ്രവർത്തിക്കുന്ന കമ്പ്യൂട്ടേഷനുകൾ) ഒരിക്കലും നടത്തരുത്. ബ്ലോക്കിംഗ് ഓപ്പറേഷനുകൾ ഒരു പ്രത്യേക ത്രെഡിലേക്കോ പ്രോസസ്സിലേക്കോ മാറ്റാൻ asyncio.to_thread() അല്ലെങ്കിൽ ഒരു പ്രോസസ്സ് പൂൾ ഉപയോഗിക്കുക.

യഥാർത്ഥ ലോകത്തിലെ ഉപയോഗങ്ങൾ

asyncio ക്യൂകളുള്ള പ്രൊഡ്യൂസർ-കൺസ്യൂമർ പാറ്റേൺ പലതരം യഥാർത്ഥ ലോക സാഹചര്യങ്ങളിൽ പ്രായോഗികമാണ്:

• വെബ് സ്ക്രാപ്പറുകൾ: പ്രൊഡ്യൂസർമാർ വെബ് പേജുകൾ എടുക്കുകയും, കൺസ്യൂമർമാർ ഡാറ്റ പാഴ്സ് ചെയ്ത് വേർതിരിച്ചെടുക്കുകയും ചെയ്യുന്നു.
• ചിത്ര/വീഡിയോ പ്രോസസ്സിംഗ്: പ്രൊഡ്യൂസർമാർ ഡിസ്കിൽ നിന്നോ നെറ്റ്‌വർക്കിൽ നിന്നോ ചിത്രങ്ങൾ/വീഡിയോകൾ വായിക്കുകയും, കൺസ്യൂമർമാർ പ്രോസസ്സിംഗ് പ്രവർത്തനങ്ങൾ (ഉദാ. വലുപ്പം മാറ്റുക, ഫിൽട്ടർ ചെയ്യുക) നടത്തുകയും ചെയ്യുന്നു.
• ഡാറ്റാ പൈപ്പ്ലൈനുകൾ: പ്രൊഡ്യൂസർമാർ വിവിധ ഉറവിടങ്ങളിൽ നിന്ന് (ഉദാ. സെൻസറുകൾ, API-കൾ) ഡാറ്റ ശേഖരിക്കുകയും, കൺസ്യൂമർമാർ ഡാറ്റയെ ഒരു ഡാറ്റാബേസിലേക്കോ ഡാറ്റാ വെയർഹൗസിലേക്കോ രൂപാന്തരപ്പെടുത്തി ലോഡ് ചെയ്യുകയും ചെയ്യുന്നു.
• മെസ്സേജ് ക്യൂകൾ: കസ്റ്റം മെസ്സേജ് ക്യൂ സിസ്റ്റങ്ങൾ നടപ്പിലാക്കുന്നതിനുള്ള ഒരു നിർമ്മാണ ഘടകമായി asyncio ക്യൂകൾ ഉപയോഗിക്കാം.
• വെബ് ആപ്ലിക്കേഷനുകളിലെ പശ്ചാത്തല ടാസ്ക് പ്രോസസ്സിംഗ്: പ്രൊഡ്യൂസർമാർ HTTP അഭ്യർത്ഥനകൾ സ്വീകരിച്ച് പശ്ചാത്തല ടാസ്ക്കുകൾ ക്യൂവിലേക്ക് ചേർക്കുന്നു, കൺസ്യൂമർമാർ ആ ടാസ്ക്കുകൾ അസിൻക്രണസ് ആയി പ്രോസസ്സ് ചെയ്യുന്നു. ഇത് പ്രധാന വെബ് ആപ്ലിക്കേഷൻ ഇമെയിലുകൾ അയക്കുകയോ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുകയോ പോലുള്ള ദീർഘനേരം പ്രവർത്തിക്കുന്ന ഓപ്പറേഷനുകളിൽ ബ്ലോക്ക് ആകുന്നത് തടയുന്നു.
• ഫിനാൻഷ്യൽ ട്രേഡിംഗ് സിസ്റ്റങ്ങൾ: പ്രൊഡ്യൂസർമാർ മാർക്കറ്റ് ഡാറ്റാ ഫീഡുകൾ സ്വീകരിക്കുന്നു, കൺസ്യൂമർമാർ ഡാറ്റ വിശകലനം ചെയ്ത് ട്രേഡുകൾ നടത്തുന്നു. അസിൻക്യോയുടെ അസിൻക്രണസ് സ്വഭാവം തത്സമയ പ്രതികരണ സമയങ്ങളും ഉയർന്ന അളവിലുള്ള ഡാറ്റ കൈകാര്യം ചെയ്യാനും അനുവദിക്കുന്നു.
• ഐഒടി ഡാറ്റാ പ്രോസസ്സിംഗ്: പ്രൊഡ്യൂസർമാർ ഐഒടി ഉപകരണങ്ങളിൽ നിന്ന് ഡാറ്റ ശേഖരിക്കുന്നു, കൺസ്യൂമർമാർ ഡാറ്റ തത്സമയം പ്രോസസ്സ് ചെയ്യുകയും വിശകലനം ചെയ്യുകയും ചെയ്യുന്നു. വിവിധ ഉപകരണങ്ങളിൽ നിന്നുള്ള ധാരാളം കൺകറൻ്റ് കണക്ഷനുകൾ കൈകാര്യം ചെയ്യാൻ സിസ്റ്റത്തെ അസിൻക്യോ പ്രാപ്തമാക്കുന്നു, ഇത് ഐഒടി ആപ്ലിക്കേഷനുകൾക്ക് അനുയോജ്യമാക്കുന്നു.

അസിൻക്യോ ക്യൂകൾക്കുള്ള ബദലുകൾ

asyncio.Queue ഒരു ശക്തമായ ഉപകരണമാണെങ്കിലും, എല്ലാ സാഹചര്യങ്ങൾക്കും ഇത് എല്ലായ്പ്പോഴും മികച്ച തിരഞ്ഞെടുപ്പല്ല. പരിഗണിക്കേണ്ട ചില ബദലുകൾ താഴെ നൽകുന്നു:

• മൾട്ടിപ്രോസസ്സിംഗ് ക്യൂകൾ: ത്രെഡുകൾ ഉപയോഗിച്ച് കാര്യക്ഷമമായി സമാന്തരമാക്കാൻ കഴിയാത്ത സിപിയു-ബൗണ്ട് പ്രവർത്തനങ്ങൾ നടത്തണമെങ്കിൽ (ഗ്ലോബൽ ഇൻ്റർപ്രെട്ടർ ലോക്ക് - GIL കാരണം), multiprocessing.Queue ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക. ഇത് പ്രൊഡ്യൂസർമാരെയും കൺസ്യൂമർമാരെയും പ്രത്യേക പ്രോസസ്സുകളിൽ പ്രവർത്തിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, GIL-നെ മറികടക്കുന്നു. എന്നിരുന്നാലും, പ്രോസസ്സുകൾ തമ്മിലുള്ള ആശയവിനിമയം ത്രെഡുകൾ തമ്മിലുള്ള ആശയവിനിമയത്തേക്കാൾ സാധാരണയായി ചെലവേറിയതാണെന്ന് ശ്രദ്ധിക്കുക.
• തേർഡ്-പാർട്ടി മെസ്സേജ് ക്യൂകൾ (ഉദാ. RabbitMQ, Kafka): കൂടുതൽ സങ്കീർണ്ണവും വിതരണം ചെയ്യപ്പെട്ടതുമായ ആപ്ലിക്കേഷനുകൾക്ക്, RabbitMQ അല്ലെങ്കിൽ Kafka പോലുള്ള ഒരു സമർപ്പിത മെസ്സേജ് ക്യൂ സിസ്റ്റം ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക. ഈ സിസ്റ്റങ്ങൾ മെസ്സേജ് റൂട്ടിംഗ്, പെർസിസ്റ്റൻസ്, സ്കേലബിലിറ്റി തുടങ്ങിയ വിപുലമായ സവിശേഷതകൾ നൽകുന്നു.
• ചാനലുകൾ (ഉദാ. ട്രിയോ): ട്രിയോ ലൈബ്രറി ചാനലുകൾ വാഗ്ദാനം ചെയ്യുന്നു, ഇത് ക്യൂകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ കൺകറൻ്റ് ടാസ്ക്കുകൾക്കിടയിൽ ആശയവിനിമയം നടത്താൻ കൂടുതൽ ഘടനാപരമായതും സംയോജിപ്പിക്കാവുന്നതുമായ ഒരു മാർഗ്ഗം നൽകുന്നു.
• aiormq (അസിൻക്യോ റാബിറ്റ്എംക്യു ക്ലയിൻ്റ്): നിങ്ങൾക്ക് പ്രത്യേകമായി RabbitMQ-ലേക്ക് ഒരു അസിൻക്രണസ് ഇൻ്റർഫേസ് ആവശ്യമുണ്ടെങ്കിൽ, aiormq ലൈബ്രറി ഒരു മികച്ച തിരഞ്ഞെടുപ്പാണ്.

ഉപസംഹാരം

പൈത്തണിൽ കൺകറൻ്റ് പ്രൊഡ്യൂസർ-കൺസ്യൂമർ പാറ്റേണുകൾ നടപ്പിലാക്കുന്നതിന് asyncio ക്യൂകൾ ശക്തവും കാര്യക്ഷമവുമായ ഒരു സംവിധാനം നൽകുന്നു. ഈ ഗൈഡിൽ ചർച്ച ചെയ്ത പ്രധാന ആശയങ്ങളും മികച്ച രീതികളും മനസ്സിലാക്കുന്നതിലൂടെ, ഉയർന്ന പ്രകടനവും, സ്കേലബിലിറ്റിയും, റെസ്പോൺസീവുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് asyncio ക്യൂകൾ പ്രയോജനപ്പെടുത്താം. നിങ്ങളുടെ പ്രത്യേക ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ പരിഹാരം കണ്ടെത്താൻ വിവിധ ക്യൂ വലുപ്പങ്ങൾ, എറർ ഹാൻഡ്ലിംഗ് തന്ത്രങ്ങൾ, വിപുലമായ പാറ്റേണുകൾ എന്നിവ ഉപയോഗിച്ച് പരീക്ഷിക്കുക. asyncio, ക്യൂകൾ എന്നിവയോടുകൂടിയ അസിൻക്രണസ് പ്രോഗ്രാമിംഗ് സ്വീകരിക്കുന്നത്, കഠിനമായ ജോലിഭാരങ്ങൾ കൈകാര്യം ചെയ്യാനും അസാധാരണമായ ഉപയോക്തൃ അനുഭവങ്ങൾ നൽകാനും കഴിയുന്ന ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ പ്രാപ്തരാക്കുന്നു.