Python Multithreading convient aux taches à forte intensité d'E / O. 1. Il convient à des scénarios tels que les demandes de réseau, la lecture et l'écriture de fichiers, l'attente des entrées des utilisateurs, etc., telles que les robots multiples peuvent enregistrer le temps d'attente de la demande; 2. Il ne convient pas aux taches à forte intensité de calcul telles que le traitement d'image et les opérations mathématiques, et ne peut pas fonctionner en parallèle en raison du verrouillage mondial des interprètes (GIL). Méthode de mise en ?uvre: vous pouvez créer et démarrer des threads via le module de threading et utiliser join () pour vous assurer que le thread principal attend que le thread de l'enfant se termine et utiliser le verrouillage pour éviter les conflits de données, mais il n'est pas recommandé de permettre trop de threads pour éviter d'inclinter les performances. De plus, le threadpoolExecutor du module simultanée. Les problèmes courants incluent les malentendus du r?le de GIL, les variables partagées déverrouillées, l'oubli de la jointure et trop de threads mènent à la concurrence des ressources, qui doit être vérifiée à travers des journaux ou des outils de débogage.

L'implémentation multi-lancement de Python est en fait un peu spéciale. Beaucoup de gens pensaient initialement que cela pourrait utiliser pleinement les processeurs multi-core comme les autres langues, mais en fait, ce n'était pas idéal. La raison principale est que Python a un verrouillage mondial d'interprète (GIL), qui ne restreint qu'un seul thread pour exécuter Python Bytecode en même temps. Cependant, cela ne signifie pas que le multithreading est inutile dans Python, il existe encore de nombreux scénarios qui peuvent être utilisés.

à quels scénarios est-il adapté au multithreading?

Le module threading de Python convient aux taches à forte intensité d'E / O , telles que les demandes de réseau, la lecture et l'écriture de fichiers, l'attente de la saisie des utilisateurs, etc. Ce type de tache attend des ressources externes la plupart du temps. à l'heure actuelle, le fil de commutation ne sera pas affecté par Gil, mais peut améliorer l'efficacité globale.

Par exemple: si vous souhaitez explorer les données de plusieurs sites Web et que chaque demande doit attendre quelques secondes pour répondre, l'ouverture de plusieurs threads pour envoyer des demandes en même temps peut gagner beaucoup de temps.

• Robot Web
• Collecte de journaux et traitement
• Empêcher le bégaiement de l'interface dans les applications GUI

Il n'est pas recommandé pour les taches à forte intensité de calcul (telles que le traitement d'image, de grandes quantités d'opérations mathématiques), car ces taches seront coincées avec GIL et ne peuvent pas être vraiment parallèles.

Comment utiliser le threading pour implémenter le multi-threading?

L'utilisation threading est le moyen le plus simple. Le processus de base consiste à créer un objet de thread, à spécifier la fonction objectif, puis à démarrer le thread.

 Filation d'importation

Def Worker ():
    imprimer ("le travailleur court")

threads = []
pour I à portée (5):
    t = filetage.thread (cible = travailleur)
    threads.append (t)
    t.start ()

Quelques points à noter:

• Si vous voulez tous les fils d'enfants tels que le fil principal à terminer, vous pouvez ajouter t.join()
• Lorsque vous partagez des données, utilisez des verrous ( threading.Lock() ) pour éviter les conflits.
• Il n'est pas recommandé d'ouvrir trop de fils, car des dizaines d'entre eux sont presque les mêmes, trop ralentira les performances.

Y a-t-il un moyen plus simple de l'écrire? Essayez simultanément.

Si vous ne souhaitez pas gérer manuellement les cycles de vie des threads, envisagez ThreadPoolExecutor dans le module concurrent.futures , qui est plus concis et plus facile à contr?ler le nombre de concurrence.

 à partir de simultanément.

def fetch_url (URL):
    # Simulez une demande de réseau renvoie f "Réponse de {url}"

urls = ["https://example.com/1", "https://example.com/2"]

avec ThreadPoolExecutor (max_workers = 5) comme exécuteur:
    résultats = list (exécutor.map (fetch_url, urls)))

Cette méthode présente plusieurs avantages:

• Gérer automatiquement la taille du pool de threads
• Prend en charge les résultats asynchrones (via les futurs objets)
• Il est plus facile à utiliser avec la carte, les fonctions AS_Completed et autres fonctions

Fosse multi-threading

Bien qu'il soit simple à utiliser, certains endroits sont sujets aux problèmes, en particulier pour les débutants.

• Le malentendu de Gil : Je pensais que je pouvais exécuter le CPU en ouvrant plusieurs fils, mais en fait, il n'était pas très utile aux taches à forte intensité de processeur.
• Les variables partagées ne sont pas verrouillées : plusieurs threads modifient une variable en même temps peut entra?ner la confusion des données.
• Join oublié : le fil principal se termine trop vite et le fil d'enfant est tué avant qu'il ne soit exécuté.
• Trop de threads : une concurrence excessive peut conduire à une concurrence sur les ressources et à la commutation de contexte.

Lorsque vous rencontrez ces problèmes, vous pouvez aussi bien imprimer le journal pour voir l'ordre d'exécution du thread ou utiliser des outils de débogage pour observer l'état du thread.

Fondamentalement, c'est tout. Le multi-threading de Python n'est pas omnipotent, mais il est toujours très pratique dans des scénarios appropriés. La ma?trise de sa portée d'application et d'utilisation peut rendre votre programme à gérer certaines taches plus efficacement.

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!