AsyncIO bilan Python korutinlarini tuzatish bo'yicha keng qamrovli qo'llanma. Butun dunyo bo'ylab barqaror asinxron ilovalar yaratish uchun xatolarga ishlov berish usullari.
AsyncIO'ni O'zlashtirish: Global Dasturchilar uchun Python Korutinlarini Tuzatish va Xatoliklarga Ishlov Berish Strategiyalari
Python'ning asyncio kutubxonasi bilan asinxron dasturlash yuqori unumdorlikka ega, kengaytiriladigan ilovalarni yaratishning asosiy tamal toshiga aylandi. Veb-serverlar va ma'lumotlar quvurlaridan tortib, IoT qurilmalari va mikroservislargacha, asyncio dasturchilarga I/O bilan bog'liq vazifalarni ajoyib samaradorlik bilan bajarish imkonini beradi. Biroq, asinxron kodning o'ziga xos murakkabligi o'ziga xos tuzatish muammolarini keltirib chiqarishi mumkin. Ushbu keng qamrovli qo'llanma Python korutinlarini tuzatish va asyncio ilovalari doirasida mustahkam xatolarga ishlov berishni amalga oshirishning samarali strategiyalarini global dasturchilar auditoriyasi uchun moslashtirilgan holda chuqur o'rganadi.
Asinxron Manzara: Nima Uchun Korutinlarni Tuzatish Muhim
An'anaviy sinxron dasturlash chiziqli bajarilish yo'lini kuzatadi, bu esa xatolarni kuzatishni nisbatan osonlashtiradi. Boshqa tomondan, asinxron dasturlash bir nechta vazifalarning bir vaqtda bajarilishini o'z ichiga oladi va ko'pincha boshqaruvni hodisalar tsikliga (event loop) qaytaradi. Bu parallelizm standart tuzatish usullari yordamida aniqlash qiyin bo'lgan nozik xatoliklarga olib kelishi mumkin. Poyga holatlari (race conditions), bloklanishlar (deadlocks) va kutilmagan vazifalarni bekor qilish kabi muammolar ko'proq uchraydi.
Turli vaqt zonalarida ishlaydigan va xalqaro loyihalarda hamkorlik qiluvchi dasturchilar uchun asyncio tuzatish va xatolarga ishlov berishni puxta tushunish juda muhimdir. Bu ilovalarning muhit, foydalanuvchi joylashuvi yoki tarmoq sharoitlaridan qat'i nazar ishonchli ishlashini ta'minlaydi. Ushbu qo'llanma sizni ushbu murakkabliklarni samarali yengib o'tish uchun bilim va vositalar bilan qurollantirishni maqsad qilgan.
Korutinlarning Bajarilishi va Hodisalar Tsiklini Tushunish
Tuzatish usullariga sho'ng'ishdan oldin, korutinlarning asyncio hodisalar tsikli bilan qanday o'zaro ta'sir qilishini tushunish juda muhimdir. Korutin — bu o'z bajarilishini to'xtatib turishi va keyinroq davom ettirishi mumkin bo'lgan maxsus funksiya turi. asyncio hodisalar tsikli asinxron bajarilishning markazidir; u korutinlarning bajarilishini boshqaradi va rejalashtiradi, ularning operatsiyalari tayyor bo'lganda ularni uyg'otadi.
Eslab qolish kerak bo'lgan asosiy tushunchalar:
async def: Korutin funksiyasini aniqlaydi.await: Kutilayotgan obyekt (awaitable) tugaguniga qadar korutin bajarilishini to'xtatib turadi. Aynan shu yerda boshqaruv hodisalar tsikliga qaytariladi.- Vazifalar (Tasks):
asynciokorutinlarni ularning bajarilishini boshqarish uchunTaskobyektlariga o'raydi. - Hodisalar Tsikli (Event Loop): Vazifalar va qayta chaqiruvlarni (callbacks) ishga tushiradigan markaziy boshqaruvchi.
await iborasi uchraganda, korutin boshqaruvdan voz kechadi. Agar kutilayotgan operatsiya I/O bilan bog'liq bo'lsa (masalan, tarmoq so'rovi, fayldan o'qish), hodisalar tsikli boshqa tayyor vazifaga o'tishi mumkin, shu tariqa parallelizmga erishiladi. Tuzatish ko'pincha korutin qachon va nima uchun to'xtashini va qanday davom etishini tushunishni o'z ichiga oladi.
Keng Tarqalgan Korutin Xatolari va Senariylari
asyncio korutinlari bilan ishlashda bir nechta keng tarqalgan muammolar yuzaga kelishi mumkin:
- Qayta Ishlanmagan Istisnolar: Korutin ichida yuzaga kelgan istisnolar, agar ushlanmasa, kutilmagan tarzda tarqalishi mumkin.
- Vazifani Bekor Qilish: Vazifalar bekor qilinishi mumkin, bu esa
asyncio.CancelledErrorga olib keladi va uni to'g'ri qayta ishlash kerak. - Bloklanishlar va Och Qolish (Deadlocks and Starvation): Sinxronizatsiya primitivlaridan noto'g'ri foydalanish yoki resurslar uchun raqobat vazifalarning cheksiz kutishiga olib kelishi mumkin.
- Poyga Holatlari (Race Conditions): Bir nechta korutinlarning umumiy resurslarga bir vaqtning o'zida to'g'ri sinxronizatsiyasiz kirishi va ularni o'zgartirishi.
- Callback Do'zaxi (Callback Hell): Zamonaviy
asyncionaqshlari bilan kamroq uchrasa-da, murakkab qayta chaqiruv zanjirlarini boshqarish va tuzatish hali ham qiyin bo'lishi mumkin. - Bloklovchi Operatsiyalar: Korutin ichida sinxron, bloklovchi I/O operatsiyalarini chaqirish butun hodisalar tsiklini to'xtatib qo'yishi va asinxron dasturlashning afzalliklarini yo'qqa chiqarishi mumkin.
AsyncIO'da Muhim Xatoliklarga Ishlov Berish Strategiyalari
Mustahkam xatoliklarga ishlov berish ilova nosozliklariga qarshi birinchi himoya chizig'idir. asyncio Python'ning standart istisnolarni qayta ishlash mexanizmlaridan foydalanadi, lekin asinxron o'ziga xosliklari bilan.
1. try...except...finallyning Kuchi
Istisnolarni qayta ishlash uchun asosiy Python konstruksiyasi korutinlarga to'g'ridan-to'g'ri qo'llaniladi. Potensial muammoli await chaqiruvlarini yoki asinxron kod bloklarini try bloki ichiga o'rang.
import asyncio
async def fetch_data(url):
print(f"{url} manzilidan ma'lumotlar olinmoqda...")
await asyncio.sleep(1) # Tarmoq kechikishini simulyatsiya qilish
if "error" in url:
raise ValueError(f"{url} manzilidan yuklashda xatolik yuz berdi")
return f"{url} manzilidan ma'lumotlar"
async def process_urls(urls):
tasks = []
for url in urls:
tasks.append(asyncio.create_task(fetch_data(url)))
results = []
for task in asyncio.as_completed(tasks):
try:
result = await task
results.append(result)
print(f"Muvaffaqiyatli qayta ishlandi: {result}")
except ValueError as e:
print(f"URL'ni qayta ishlashda xatolik: {e}")
except Exception as e:
print(f"Kutilmagan xatolik yuz berdi: {e}")
finally:
# Bu yerdagi kod istisno yuz bergan yoki bermaganidan qat'i nazar ishlaydi
print("Bitta vazifani qayta ishlash tugallandi.")
return results
async def main():
urls = [
"http://example.com/data1",
"http://example.com/error_source",
"http://example.com/data2"
]
await process_urls(urls)
if __name__ == "__main__":
asyncio.run(main())
Izoh:
- Bir nechta
fetch_datakorutinlarini rejalashtirish uchunasyncio.create_taskdan foydalanamiz. asyncio.as_completedvazifalar tugashi bilan ularni qaytaradi, bu esa natijalar yoki xatolarni zudlik bilan qayta ishlash imkonini beradi.- Har bir
await taskbizning simulyatsiya qilingan API tomonidan yuzaga keltirilgan maxsusValueErroristisnolarini, shuningdek, boshqa kutilmagan istisnolarni ushlash uchuntry...exceptbloki ichiga o'ralgan. finallybloki resurslarni bo'shatish yoki log yozish kabi har doim bajarilishi kerak bo'lgan tozalash operatsiyalari uchun foydalidir.
2. asyncio.CancelledErrorni Qayta Ishlash
asyncioda vazifalar bekor qilinishi mumkin. Bu uzoq davom etadigan operatsiyalarni boshqarish yoki ilovalarni to'g'ri yopish uchun juda muhimdir. Vazifa bekor qilinganda, vazifa oxirgi marta boshqaruvni topshirgan nuqtada (ya'ni, awaitda) asyncio.CancelledError yuzaga keladi. Har qanday zarur tozalash ishlarini bajarish uchun buni ushlash muhim.
import asyncio
async def cancellable_task():
try:
for i in range(5):
print(f"Vazifa qadami {i}")
await asyncio.sleep(1)
print("Vazifa normal yakunlandi.")
except asyncio.CancelledError:
print("Vazifa bekor qilindi! Tozalash ishlari bajarilmoqda...")
# Tozalash operatsiyalarini simulyatsiya qilish
await asyncio.sleep(0.5)
print("Tozalash tugallandi.")
raise # Agar qoidaga ko'ra talab qilinsa, CancelledError'ni qayta yuzaga keltirish
finally:
print("Bu finally bloki har doim ishlaydi.")
async def main():
task = asyncio.create_task(cancellable_task())
await asyncio.sleep(2.5) # Vazifani biroz ishlashiga imkon berish
print("Vazifa bekor qilinmoqda...")
task.cancel()
try:
await task # Vazifaning bekor qilinganligini tan olishini kutish
except asyncio.CancelledError:
print("Main vazifa bekor qilinganidan keyin CancelledError'ni ushladi.")
if __name__ == "__main__":
asyncio.run(main())
Izoh:
cancellable_taskdatry...except asyncio.CancelledErrorbloki mavjud.exceptbloki ichida biz tozalash amallarini bajaramiz.- Muhimi, tozalashdan so'ng,
CancelledErrorko'pincha qayta yuzaga keltiriladi. Bu chaqiruvchiga vazifaning haqiqatan ham bekor qilinganligini bildiradi. Agar siz uni qayta yuzaga keltirmasdan bostirsangiz, chaqiruvchi vazifa muvaffaqiyatli yakunlandi deb o'ylashi mumkin. mainfunksiyasi vazifani qanday bekor qilishni va keyin uniawaitqilishni ko'rsatadi. Agar vazifa bekor qilingan va qayta yuzaga keltirilgan bo'lsa, buawait taskchaqiruvchidaCancelledErrorni yuzaga keltiradi.
3. asyncio.gatherni Istisnolarni Qayta Ishlash Bilan Ishlatish
asyncio.gather bir nechta kutiladigan obyektlarni (awaitables) bir vaqtda ishga tushirish va ularning natijalarini yig'ish uchun ishlatiladi. Standart holatda, agar biron bir kutiladigan obyekt istisno yuzaga keltirsa, gather darhol birinchi uchragan istisnoni tarqatadi va qolgan kutiladigan obyektlarni bekor qiladi.
gather chaqiruvi ichidagi alohida korutinlardan kelgan istisnolarni qayta ishlash uchun return_exceptions=True argumentidan foydalanishingiz mumkin.
import asyncio
async def successful_operation(delay):
await asyncio.sleep(delay)
return f"Muvaffaqiyat {delay}s dan keyin"
async def failing_operation(delay):
await asyncio.sleep(delay)
raise RuntimeError(f"Xatolik {delay}s dan keyin")
async def main():
results = await asyncio.gather(
successful_operation(1),
failing_operation(0.5),
successful_operation(1.5),
return_exceptions=True
)
print("Gather'dan olingan natijalar:")
for i, result in enumerate(results):
if isinstance(result, Exception):
print(f"Vazifa {i}: Istisno bilan yakunlandi: {result}")
else:
print(f"Vazifa {i}: Muvaffaqiyatli yakunlandi, natija: {result}")
if __name__ == "__main__":
asyncio.run(main())
Izoh:
return_exceptions=Truebilan, agar istisno yuz bersa,gatherto'xtamaydi. Buning o'rniga, istisno obyekti o'zi natijalar ro'yxatida tegishli o'ringa joylashtiriladi.- So'ngra kod natijalar bo'ylab iteratsiya qiladi va har bir elementning turini tekshiradi. Agar u
Exceptionbo'lsa, bu o'sha vazifa muvaffaqiyatsiz bo'lganini anglatadi.
4. Resurslarni Boshqarish uchun Kontekst Menejerlari
Kontekst menejerlari (async with yordamida) xatolar yuz berganda ham resurslarning to'g'ri olinishi va bo'shatilishini ta'minlash uchun ajoyib vositadir. Bu ayniqsa tarmoq ulanishlari, fayl dastaklari yoki qulflar uchun foydalidir.
import asyncio
class AsyncResource:
def __init__(self, name):
self.name = name
self.acquired = False
async def __aenter__(self):
print(f"Resurs olinmoqda: {self.name}")
await asyncio.sleep(0.2) # Olish vaqtini simulyatsiya qilish
self.acquired = True
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
print(f"Resurs bo'shatilmoqda: {self.name}")
await asyncio.sleep(0.2) # Bo'shatish vaqtini simulyatsiya qilish
self.acquired = False
if exc_type:
print(f"Kontekst ichida istisno yuz berdi: {exc_type.__name__}: {exc_val}")
# Istisnoni bostirish uchun True, tarqatish uchun False yoki None qaytaring
return False # Standart holatda istisnolarni tarqatish
async def use_resource(name):
try:
async with AsyncResource(name) as resource:
print(f"{resource.name} resursidan foydalanilmoqda...")
await asyncio.sleep(1)
if name == "flaky_resource":
raise RuntimeError("Resursdan foydalanish paytida simulyatsiya qilingan xatolik")
print(f"{resource.name} resursidan foydalanish tugallandi.")
except RuntimeError as e:
print(f"Kontekst menejeridan tashqarida istisno ushlandi: {e}")
async def main():
await use_resource("stable_resource")
print("---")
await use_resource("flaky_resource")
if __name__ == "__main__":
asyncio.run(main())
Izoh:
AsyncResourcesinfi asinxron kontekstni boshqarish uchun__aenter__va__aexit__metodlarini amalga oshiradi.__aenter__async withblokiga kirganda chaqiriladi, va__aexit__istisno yuz bergan yoki bermaganidan qat'i nazar, chiqishda chaqiriladi.__aexit__parametrlariga (exc_type,exc_val,exc_tb) yuz bergan har qanday istisno haqida ma'lumot beriladi.__aexit__danTrueqaytarish istisnoni bostiradi,FalseyokiNoneqaytarish esa uning tarqalishiga imkon beradi.
Korutinlarni Samarali Tuzatish
Asinxron kodni tuzatish sinxron kodni tuzatishdan farqli yondashuv va vositalarni talab qiladi.
1. Log Yuritishdan Strategik Foydalanish
Log yuritish asinxron ilovalarning oqimini tushunish uchun ajralmas vositadir. Bu sizga hodisalarni, o'zgaruvchilar holatini va istisnolarni bajarilishni to'xtatmasdan kuzatish imkonini beradi. Python'ning o'rnatilgan logging modulidan foydalaning.
import asyncio
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
async def log_task(name, delay):
logging.info(f"'{name}' vazifasi boshlandi.")
try:
await asyncio.sleep(delay)
if delay > 1:
raise ValueError(f"Uzoq kechikish tufayli '{name}' uchun simulyatsiya qilingan xatolik.")
logging.info(f"'{name}' vazifasi {delay}s dan keyin muvaffaqiyatli yakunlandi.")
except asyncio.CancelledError:
logging.warning(f"'{name}' vazifasi bekor qilindi.")
raise
except Exception as e:
logging.error(f"'{name}' vazifasida xatolik yuz berdi: {e}")
raise
async def main():
tasks = [
asyncio.create_task(log_task("Vazifa A", 1)),
asyncio.create_task(log_task("Vazifa B", 2)),
asyncio.create_task(log_task("Vazifa C", 0.5))
]
await asyncio.gather(*tasks, return_exceptions=True)
logging.info("Barcha vazifalar yakunlandi.")
if __name__ == "__main__":
asyncio.run(main())
AsyncIO'da log yuritish bo'yicha maslahatlar:
- Vaqt Belgilari: Turli vazifalar bo'ylab hodisalarni bog'lash va vaqtni tushunish uchun muhim.
- Vazifani Identifikatsiyalash: Amalni bajarayotgan vazifaning nomini yoki identifikatorini logga yozing.
- Korrelyatsiya ID'lari: Tarqoq tizimlar uchun so'rovni bir nechta xizmatlar va vazifalar bo'ylab kuzatish uchun korrelyatsiya ID'sidan foydalaning.
- Strukturaviy Log Yuritish: Turli muhitlardan loglarni tahlil qilayotgan xalqaro jamoalar uchun foydali bo'lgan, yanada tartibli va so'rovga yaroqli log ma'lumotlari uchun
structlogkabi kutubxonalardan foydalanishni o'ylab ko'ring.
2. Standart Tuzatuvchilardan Foydalanish (ehtiyotkorlik bilan)
pdb (yoki IDE tuzatuvchilari) kabi standart Python tuzatuvchilaridan foydalanish mumkin, lekin ular asinxron kontekstlarda ehtiyotkorlik bilan ishlashni talab qiladi. Tuzatuvchi bajarilishni to'xtatganda, butun hodisalar tsikli pauza qilinadi. Bu adashtiruvchi bo'lishi mumkin, chunki u bir vaqtda bajarilishni aniq aks ettirmaydi.
pdbdan qanday foydalanish kerak:
- Bajarilishni to'xtatmoqchi bo'lgan joyga
import pdb; pdb.set_trace()qo'ying. - Tuzatuvchi to'xtaganda, siz o'zgaruvchilarni tekshirishingiz, kod bo'ylab qadam-baqadam yurishingiz (garchi
awaitbilan qadamlash qiyin bo'lishi mumkin) va ifodalarni baholashingiz mumkin. awaitustidan qadam tashlash tuzatuvchini kutilayotgan korutin tugaguniga qadar to'xtatib qo'yishini unutmang, bu esa uni o'sha paytda ketma-ket bajarilishga majbur qiladi.
breakpoint() bilan Kengaytirilgan Tuzatish (Python 3.7+):
O'rnatilgan breakpoint() funksiyasi yanada moslashuvchan va turli tuzatuvchilardan foydalanish uchun sozlanishi mumkin. Siz PYTHONBREAKPOINT muhit o'zgaruvchisini o'rnatishingiz mumkin.
AsyncIO uchun tuzatish vositalari:
Ba'zi IDE'lar (masalan, PyCharm) asinxron kodni tuzatish uchun kengaytirilgan qo'llab-quvvatlashni taklif etadi, korutin holatlari uchun vizual ko'rsatkichlar va osonroq qadamlash imkoniyatini beradi.
3. AsyncIO'da Stek Izlarini (Stack Traces) Tushunish
Asyncio stek izlari ba'zan hodisalar tsiklining tabiati tufayli murakkab bo'lishi mumkin. Istisno sizning korutiningiz kodi bilan bir qatorda hodisalar tsiklining ichki ishlashi bilan bog'liq freymlarni ko'rsatishi mumkin.
Asinxron stek izlarini o'qish bo'yicha maslahatlar:
- O'z kodingizga e'tibor qarating: Ilovangiz kodidan kelib chiqqan freymlarni aniqlang. Ular odatda izning yuqori qismida paydo bo'ladi.
- Kelib chiqishni kuzating: Istisno birinchi marta qayerda yuzaga kelganini va u sizning
awaitchaqiruvlaringiz orqali qanday tarqalganini qidiring. asyncio.run_coroutine_threadsafe: Agar potoklar (threads) bo'ylab tuzatayotgan bo'lsangiz, korutinlarni ular o'rtasida o'tkazishda istisnolar qanday qayta ishlanishiga e'tibor bering.
4. asyncio Tuzatish Rejimidan Foydalanish
asyncio o'rnatilgan tuzatish rejimiga ega bo'lib, u keng tarqalgan dasturlash xatolarini aniqlashga yordam beradigan tekshiruvlar va log yozuvlarini qo'shadi. Uni asyncio.run() ga debug=True ni o'tkazish yoki PYTHONASYNCIODEBUG muhit o'zgaruvchisini o'rnatish orqali yoqing.
import asyncio
async def potentially_buggy_coro():
# Bu soddalashtirilgan misol. Tuzatish rejimi yanada nozik muammolarni aniqlaydi.
await asyncio.sleep(0.1)
# Masalan: Agar bu tasodifan tsiklni bloklasa
async def main():
print("Asyncio tuzatish rejimi yoqilgan holda ishga tushirilmoqda.")
await potentially_buggy_coro()
if __name__ == "__main__":
asyncio.run(main(), debug=True)
Tuzatish rejimi nimalarni aniqlaydi:
- Hodisalar tsiklidagi bloklovchi chaqiruvlar.
awaitqilinmagan korutinlar.- Qayta chaqiruvlardagi (callbacks) qayta ishlanmagan istisnolar.
- Vazifani bekor qilishdan noto'g'ri foydalanish.
Tuzatish rejimidagi chiqish ma'lumotlari ko'p bo'lishi mumkin, ammo u hodisalar tsiklining ishlashi va asyncio API'laridan noto'g'ri foydalanish ehtimoli haqida qimmatli ma'lumotlar beradi.
5. Kengaytirilgan Asinxron Tuzatish uchun Vositalar
Standart vositalardan tashqari, maxsus usullar tuzatishga yordam berishi mumkin:
aiomonitor: Ishlayotganasyncioilovalari uchun jonli tekshiruv interfeysini ta'minlaydigan kuchli kutubxona, tuzatuvchiga o'xshaydi, lekin bajarilishni to'xtatmaydi. Siz ishlayotgan vazifalarni, qayta chaqiruvlarni va hodisalar tsikli holatini tekshirishingiz mumkin.- Maxsus Vazifa Fabrikalari (Custom Task Factories): Murakkab stsenariylar uchun, ilovangizda yaratilgan har bir vazifaga asbob-uskunalar (instrumentation) yoki log yozuvlarini qo'shish uchun maxsus vazifa fabrikalarini yaratishingiz mumkin.
- Profilaktika (Profiling):
cProfilekabi vositalar unumdorlikdagi to'siqlarni aniqlashga yordam beradi, ular ko'pincha parallelizm muammolari bilan bog'liq.
AsyncIO'da Global Jihatlarni Boshqarish
Global auditoriya uchun asinxron ilovalarni ishlab chiqish o'ziga xos qiyinchiliklarni keltirib chiqaradi va ehtiyotkorlik bilan ko'rib chiqishni talab qiladi:
- Vaqt Zonalari: Vaqtga sezgir operatsiyalar (rejalashtirish, log yuritish, taym-autlar) turli vaqt zonalarida qanday ishlashiga e'tibor bering. Ichki vaqt belgilari uchun doimo UTC dan foydalaning.
- Tarmoq Kechikishi va Ishonchliligi: Asinxron dasturlash ko'pincha kechikishni kamaytirish uchun ishlatiladi, ammo juda o'zgaruvchan yoki ishonchsiz tarmoqlar mustahkam qayta urinish mexanizmlarini va to'g'ri ishdan chiqishni talab qiladi. Xatolarga ishlov berishingizni simulyatsiya qilingan tarmoq sharoitlarida sinab ko'ring (masalan,
toxiproxykabi vositalar yordamida). - Internatsionalizatsiya (i18n) va Lokalizatsiya (l10n): Xato xabarlari oson tarjima qilinadigan qilib yaratilishi kerak. Xato xabarlariga mamlakatga xos formatlar yoki madaniy havolalarni kiritishdan saqlaning.
- Resurs Cheklovlari: Turli mintaqalarda o'tkazuvchanlik yoki hisoblash quvvati turlicha bo'lishi mumkin. Taym-autlar va resurslar uchun raqobatni to'g'ri boshqarishni loyihalash muhimdir.
- Ma'lumotlar Muvofiqligi: Tarqoq asinxron tizimlar bilan ishlaganda, turli geografik joylashuvlarda ma'lumotlar muvofiqligini ta'minlash qiyin bo'lishi mumkin.
Misol: asyncio.wait_for bilan Global Taym-autlar
asyncio.wait_for vazifalarning cheksiz ishlashini oldini olish uchun muhimdir, bu butun dunyo bo'ylab foydalanuvchilarga xizmat ko'rsatadigan ilovalar uchun hal qiluvchi ahamiyatga ega.
import asyncio
import time
async def long_running_task(duration):
print(f"{duration} soniya davom etadigan vazifa boshlanmoqda.")
await asyncio.sleep(duration)
print("Vazifa tabiiy ravishda tugadi.")
return "Vazifa Yakunlandi"
async def main():
print(f"Hozirgi vaqt: {time.strftime('%X')}")
try:
# Barcha operatsiyalar uchun global taym-aut o'rnatish
result = await asyncio.wait_for(long_running_task(5), timeout=3.0)
print(f"Operatsiya muvaffaqiyatli: {result}")
except asyncio.TimeoutError:
print(f"Operatsiya 3 soniyadan keyin vaqt tugashi sababli to'xtatildi!")
except Exception as e:
print(f"Kutilmagan xatolik yuz berdi: {e}")
print(f"Hozirgi vaqt: {time.strftime('%X')}")
if __name__ == "__main__":
asyncio.run(main())
Izoh:
asyncio.wait_forkutiladigan obyektni (bu yerda,long_running_task) o'raydi va agar kutiladigan obyekt belgilangantimeoutichida tugamasa,asyncio.TimeoutErrorni yuzaga keltiradi.- Bu foydalanuvchiga yo'naltirilgan ilovalar uchun o'z vaqtida javob berish va resurslarning tugashini oldini olish uchun hayotiy muhimdir.
AsyncIO'da Xatoliklarga Ishlov Berish va Tuzatish bo'yicha Eng Yaxshi Amaliyotlar
Global auditoriya uchun mustahkam va qo'llab-quvvatlanadigan asinxron Python ilovalarini yaratish uchun ushbu eng yaxshi amaliyotlarga rioya qiling:
- Istisnolar bilan Aniq Bo'ling: Keng qamrovli
except Exceptiono'rniga, iloji boricha aniq istisnolarni ushlang. Bu sizning kodingizni tushunarliroq qiladi va kutilmagan xatolarni yashirishga kamroq moyil bo'ladi. asyncio.gather(..., return_exceptions=True)dan Oqilona Foydalaning: Bu barcha vazifalarning yakunlanishiga harakat qilishini xohlagan stsenariylar uchun ajoyib, ammo aralash natijalarni (muvaffaqiyatlar va muvaffaqiyatsizliklar) qayta ishlashga tayyor bo'ling.- Mustahkam Qayta Urinish Mantig'ini Amalga Oshiring: Vaqtinchalik nosozliklarga moyil bo'lgan operatsiyalar uchun (masalan, tarmoq chaqiruvlari), darhol muvaffaqiyatsizlikka uchramasdan, kechikishlar bilan aqlli qayta urinish strategiyalarini amalga oshiring.
backoffkabi kutubxonalar juda foydali bo'lishi mumkin. - Log Yuritishni Markazlashtiring: Log yuritish konfiguratsiyangiz ilovangiz bo'ylab bir xil bo'lishini va global jamoa tomonidan tuzatish uchun oson kirish imkoniyatiga ega bo'lishini ta'minlang. Oson tahlil qilish uchun strukturaviy log yuritishdan foydalaning.
- Kuzatuvchanlik uchun Loyihalang: Log yuritishdan tashqari, ishlab chiqarishda ilova xatti-harakatlarini tushunish uchun metrikalar va kuzatuvni ko'rib chiqing. Prometheus, Grafana va tarqoq kuzatuv tizimlari (masalan, Jaeger, OpenTelemetry) kabi vositalar bebaho.
- Puxta Sinovdan O'tkazing: Asinxron kod va xatolik sharoitlariga maxsus mo'ljallangan birlik va integratsiya testlarini yozing.
pytest-asynciokabi vositalardan foydalaning. Testlaringizda tarmoq nosozliklari, taym-autlar va bekor qilishlarni simulyatsiya qiling. - O'z Parallelizm Modelingizni Tushuning:
asyncioni bitta potokda, bir nechta potokda (run_in_executororqali) yoki jarayonlar bo'ylab ishlatayotganingizni aniq biling. Bu xatolarning qanday tarqalishiga va tuzatish qanday ishlashiga ta'sir qiladi. - Taxminlarni Hujjatlashtiring: Ayniqsa, global auditoriya uchun qurayotganda, tarmoq ishonchliligi, xizmat mavjudligi yoki kutilayotgan kechikish haqida qilingan har qanday taxminlarni aniq hujjatlashtiring.
Xulosa
asyncio korutinlarida tuzatish va xatolarga ishlov berish zamonaviy, yuqori unumdorlikka ega ilovalarni yaratayotgan har qanday Python dasturchisi uchun muhim ko'nikmalardir. Asinxron bajarilishning nozik jihatlarini tushunib, Python'ning mustahkam istisnolarga ishlov berishidan foydalanib va strategik log yuritish hamda tuzatish vositalarini qo'llab, siz global miqyosda barqaror, ishonchli va unumdor ilovalarni yarata olasiz.
try...except kuchini qabul qiling, asyncio.CancelledError va asyncio.TimeoutErrorni o'zlashtiring va har doim global foydalanuvchilaringizni yodda tuting. Tirishqoqlik va to'g'ri strategiyalar bilan siz asinxron dasturlashning murakkabliklarini yengib o'tib, butun dunyo bo'ylab ajoyib dasturiy ta'minot yetkazib bera olasiz.