La multi-threading en Python expliquée en 8 minutes

Table des matières

• Introduction
• La multi-threading en Python
• Le verrouillage de l'interpréteur global
• Utilisation du module threading
• Un exemple simple de multi-threading
• Gestion des entrées utilisateur
• Utilisation de threads démon
• Transmission des arguments aux threads
• Attente de la fin des threads
• Conclusion

Introduction

La multi-threading est une technique avancée en programmation qui permet d'exécuter plusieurs tâches simultanément. Dans cet article, nous allons explorer la multi-threading en Python et voir comment l'utiliser efficacement pour améliorer les performances de nos programmes. Nous commencerons par comprendre le fonctionnement de la multi-threading en Python, en particulier le verrouillage de l'interpréteur global. Ensuite, nous utiliserons le module threading pour créer des threads et les exécuter en parallèle. Nous découvrirons également comment gérer les entrées utilisateur et utiliser des threads démon pour des tâches en arrière-plan. Enfin, nous aborderons la transmission d'arguments aux threads et l'attente de leur fin.

La multi-threading en Python

Python, en tant que langage interprété, utilise un verrouillage de l'interpréteur global pour garantir la cohérence de l'état interne de l'interpréteur. Cela signifie qu'un seul thread Python peut être exécuté à la fois, même sur les machines avec plusieurs cœurs de processeur. Le verrouillage de l'interpréteur global limite la véritable parallélisme des threads en Python, ce qui rend le multi-threading moins efficace que dans certains autres langages. Cependant, la multi-threading en Python peut toujours être utilisée pour exécuter des tâches en parallèle en utilisant le temps d'attente des autres tâches.

Utilisation du module threading

Python propose un module intégré appelé threading qui facilite la création et la gestion des threads. Pour commencer à utiliser le multi-threading en Python, il vous suffit d'importer ce module en tapant import threading. Vous pourrez alors utiliser les classes et les fonctions fournies par le module pour créer et contrôler les threads.

Un exemple simple de multi-threading

Pour mieux comprendre le fonctionnement de la multi-threading en Python, nous allons commencer par un exemple simple. Nous allons créer une fonction appelée worker qui imprimera un compteur à intervalles réguliers. Cette fonction sera exécutée en parallèle avec la fonction principale du programme. Nous utiliserons également une boucle pour attendre l'entrée de l'utilisateur.

import threading
import time

def worker():
    done = False
    counter = 0
    while not done:
        time.sleep(1)
        counter += 1
        print(counter)

while True:
    user_input = input("Appuyez sur Entrée pour quitter : ")
    if user_input == "":
        break

worker_thread = threading.Thread(target=worker)
worker_thread.start()

Gestion des entrées utilisateur

Dans l'exemple précédent, nous utilisons une boucle pour attendre que l'utilisateur appuie sur la touche Entrée pour quitter le programme. Cette boucle bloquera l'exécution du reste du code jusqu'à ce que l'entrée utilisateur soit détectée. La multi-threading nous permet de continuer l'exécution d'autres tâches en parallèle, même lorsqu'une tâche est en attente d'une entrée utilisateur.

Utilisation de threads démon

Lorsque nous utilisons la multi-threading en Python, nous pouvons spécifier si un thread est un thread démon ou non. Un thread démon est un thread de service qui s'exécute en arrière-plan et se termine lorsque tous les autres threads non démons ont terminé leur exécution. Cela signifie que si nous n'avons que des threads démons en cours d'exécution, le programme se terminera automatiquement lorsque la tâche principale sera terminée.

Transmission des arguments aux threads

Il est possible de transmettre des arguments aux threads que nous créons. Par exemple, nous pouvons passer des valeurs ou des objets à notre fonction worker. Pour ce faire, nous utilisons le paramètre args lors de la création de l'objet thread. Les arguments sont passés sous forme de tuple et peuvent être récupérés dans la fonction worker pour être utilisés.

Attente de la fin des threads

Lorsque nous exécutons plusieurs threads en parallèle, il peut être nécessaire d'attendre que tous les threads aient terminé leur exécution avant de poursuivre ou de terminer le programme. Pour cela, nous utilisons la méthode join() sur chaque thread que nous voulons attendre. Cette méthode bloque l'exécution du programme jusqu'à ce que le thread concerné se termine.

Conclusion

La multi-threading est un outil puissant pour exécuter des tâches en parallèle en Python. Bien qu'il y ait certaines limitations en raison du verrouillage de l'interpréteur global, la multi-threading peut toujours améliorer les performances de nos programmes en utilisant le temps d'attente des tâches. En utilisant le module threading, nous pouvons créer et contrôler facilement des threads en Python. Nous avons également exploré la gestion des entrées utilisateur, l'utilisation de threads démon, la transmission d'arguments aux threads et l'attente de leur fin.

Pour en savoir plus sur la multi-threading en Python, consultez les ressources suivantes :

• Documentation officielle du module threading

FAQ :

Q : Est-il possible de créer des threads supplémentaires en utilisant le module threading ? R : Oui, vous pouvez créer autant de threads que nécessaire en utilisant le module threading.

Q : Existe-t-il d'autres moyens de réaliser des tâches simultanées en Python ? R : Oui, en plus de la multi-threading, vous pouvez également utiliser la multi-processus, l'asynchronisme ou les coroutines pour exécuter des tâches simultanément en Python.