Gestion des exceptions dans la programmation simultanée Python : assurer la stabilité des applications

python Concurrency Gestion des exceptions Multi-threading Coroutine multi-processus

Multi-threading

Dans un environnement multi-thread, chaque thread a son propre flux d'exécution et sa propre pile. Lorsqu'une exception se produit, elle n'affecte généralement que ce thread spécifique. Pour gérer les exceptions dans les fils de discussion, vous pouvez utiliser l'attribut threading.Thread() 的 join() 方法或 Thread.exc_info.

import threading

def worker_thread(name):
print(f"{name}: Starting")
raise RuntimeError("Error in thread")

try:
threads = []
for i in range(5):
thread = threading.Thread(target=worker_thread, args=(f"Thread {i}",))
threads.append(thread)

for thread in threads:
thread.start()
thread.join()
except RuntimeError as exc:
print(f"Main thread: Exception occurred in child thread: {exc}")

Processus multiples

Dans un environnement multi-processus, chaque processus possède son propre espace mémoire et son propre flux d'exécution indépendants. Lorsqu’une exception se produit, cela affecte l’ensemble du processus. Pour gérer les exceptions dans le processus, vous pouvez utiliser l'attribut multiprocessing.Process() 的 join() 方法或 Process.exitcode.

import multiprocessing

def worker_process(name):
print(f"{name}: Starting")
raise RuntimeError("Error in process")

try:
processes = []
for i in range(5):
process = multiprocessing.Process(target=worker_process, args=(f"Process {i}",))
processes.append(process)

for process in processes:
process.start()
process.join()
except RuntimeError as exc:
print(f"Main process: Exception occurred in child process: {exc}")

Coroutine

Les coroutines sont des threads légers qui s'exécutent dans un environnement monothread. Lorsqu'une exception se produit, elle est propagée à l'appelant de la coroutine. Pour gérer les exceptions dans les coroutines, vous pouvez utiliser la méthode asyncio.Task.exception().

import asyncio

async def worker_coroutine(name):
print(f"{name}: Starting")
raise RuntimeError("Error in coroutine")

async def main():
tasks = []
for i in range(5):
task = asyncio.create_task(worker_coroutine(f"Coroutine {i}"))
tasks.append(task)

for task in tasks:
try:
await task
except RuntimeError as exc:
print(f"Main coroutine: Exception occurred in child coroutine: {exc}")

asyncio.run(main())

Bonnes pratiques

• Toujours détecter et gérer les exceptions pour éviter les plantages du programme.
• Utilisez des types d’exceptions clairs pour transmettre des messages d’erreur clairs.
• Envisagez d'utiliser le mécanisme de journalisation des exceptions loggingpour suivre et analyser les exceptions.
• Utilisez des exceptions sous-classées ou des classes d'exceptions personnalisées pour créer des types d'exceptions spécifiques.
• Dans les applications simultanées, utilisez des structures de données thread-safe et des mécanismes de synchronisation pour éviter les courses de données.

Conclusion

Dans la concurrence

Python

, la gestion des exceptions est cruciale car elle garantit que l'application reste stable et fiable dans des circonstances anormales. En maîtrisant les techniques de gestion des exceptions en multithreading, multitraitement et coroutines, les développeurs peuvent créer des applications simultanées robustes et fiables. N'oubliez pas de détecter et de gérer les exceptions et de suivre les meilleures pratiques pour améliorer la qualité globale de votre application et de votre expérience utilisateur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!