Python - Main Thread (Français)

Bonjour, aspirants programmeurs !aujourd'hui, nous allons embarquer sur un voyage passionnant dans le monde du threading Python, en nous concentrant sur le fil principal. En tant que votre enseignant de sciences informatiques amical et voisin, je suis là pour vous guider à travers ce sujet fascinant. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; nous commencerons par les bases et nous travaillerons notre chemin vers le haut. Alors, prenez votre boisson préférée, mettez-vous à l'aise, et plongeons-y !

Qu'est-ce que le Fil Principal ?

Avant d'aller dans les détails, voyons ce qu'est un fil. Imaginez que vous lisez un livre tout en écoutant de la musique. Votre cerveau effectue deux tâches simultanément – c'est un peu comme les fils fonctionnent en programmation. Le fil principal est comme l'intrigue principale de votre programme, celle qui commence lorsque vous exécutez votre script Python.

Le Fil Principal en Action

Commençons par un exemple simple pour voir le fil principal en action :

import threading
import time

def print_current_thread():
print(f"Fil actuel : {threading.current_thread().name}")

print_current_thread()
time.sleep(2)
print("Le fil principal continue de s'exécuter !")

Lorsque vous exécutez ce script, vous verrez quelque chose comme :

Fil actuel : MainThread
Le fil principal continue de s'exécuter !

Dans cet exemple, nous utilisons le module threading pour accéder aux informations sur le fil actuel. La fonction time.sleep(2) est juste là pour ajouter une petite pause, comme une ellipse dramatique dans notre histoire de programmation.

Accès au Fil Principal

Maintenant que nous avons vu le fil principal en action, apprenons comment y accéder directement. Python nous offre un moyen pratique pour cela :

import threading

main_thread = threading.main_thread()
print(f"Nom du fil principal : {main_thread.name}")
print(f"ID du fil principal : {main_thread.ident}")

Ce script affichera quelque chose comme :

Nom du fil principal : MainThread
ID du fil principal : 140735268892672

L'ident est un identifiant unique pour le fil. C'est comme un numéro de sécurité sociale pour les fils – deux fils ne peuvent pas avoir le même ID.

Vérification de la Présence dans le Fil Principal

Parfois, vous pourriez vouloir vérifier si votre code s'exécute dans le fil principal. Voici comment vous pouvez le faire :

import threading

def suis_je_le_principal():
return threading.current_thread() == threading.main_thread()

print(f"Sommes-nous dans le fil principal ? {suis_je_le_principal()}")

def pas_le_principal():
print(f"Sommes-nous dans le fil principal maintenant ? {suis_je_le_principal()}")

thread = threading.Thread(target=pas_le_principal)
thread.start()
thread.join()

Ce script affichera :

Sommes-nous dans le fil principal ? True
Sommes-nous dans le fil principal maintenant ? False

Dans cet exemple, nous créons un nouveau fil qui exécute la fonction pas_le_principal(). Lorsque nous appelons suis_je_le_principal() à partir de ce nouveau fil, il retourne False.

Comportement du Fil Principal en Python

Le fil principal en Python a des comportements intéressants qui sont importants à comprendre. Explorons-les !

Le Fil Principal et la Terminaison du Programme

Un comportement clé du fil principal est que lorsque celui-ci termine son exécution, l'ensemble du programme Python se termine généralement. Voyons cela en action :

import threading
import time

def longue_tache():
print("Début d'une longue tâche...")
time.sleep(5)
print("Longue tâche terminée !")

thread = threading.Thread(target=longue_tache)
thread.start()

print("Le fil principal est terminé !")

Si vous exécutez ce script, vous verrez probablement :

Début d'une longue tâche...
Le fil principal est terminé !

Notez que le message "Longue tâche terminée !" n'apparaît jamais. C'est parce que le fil principal a terminé et que le programme s'est terminé avant que la longue tâche ne puisse se compléter.

Threads Démon vs Threads Non-Démon

Pour comprendre mieux le comportement du fil principal, nous devons parler des threads démon. Un thread démon est comme une tâche de fond qui ne empêche pas le programme de se fermer. Modifions notre exemple précédent :

import threading
import time

def longue_tache():
print("Début d'une longue tâche...")
time.sleep(5)
print("Longue tâche terminée !")

thread = threading.Thread(target=longue_tache)
thread.daemon = True  # Définir le fil comme un démon
thread.start()

print("Le fil principal est terminé !")

L'affichage sera le même que précédemment. Cependant, si nous supprimons la ligne thread.daemon = True, nous verrons :

Début d'une longue tâche...
Le fil principal est terminé !
Longue tâche terminée !

C'est parce que les threads non-démon (par défaut) empêchent le programme de se fermer jusqu'à ce qu'ils soient complets.

Le Fil Principal Attend les Autres Fils

Souvent, vous voudrez que votre fil principal attende que les autres fils se terminent avant de finir le programme. Python offre un moyen simple pour cela :

import threading
import time

def tache(nom):
print(f"Tâche {nom} en cours de démarrage...")
time.sleep(2)
print(f"Tâche {nom} terminée !")

threads = []
for i in range(3):
t = threading.Thread(target=tache, args=(f"T{i}",))
threads.append(t)
t.start()

for t in threads:
t.join()

print("Toutes les tâches sont terminées !")

Ce script affichera :

Tâche T0 en cours de démarrage...
Tâche T1 en cours de démarrage...
Tâche T2 en cours de démarrage...
Tâche T0 terminée !
Tâche T1 terminée !
Tâche T2 terminée !
Toutes les tâches sont terminées !

La méthode join() fait que le fil principal attend jusqu'à ce que chaque fil ait terminé son travail.

Une Table des Méthodes Utiles de Threading

Voici une table des quelques méthodes utiles de threading que nous avons discutées et quelques autres :

Méthode	Description
threading.current_thread()	Retourne l'objet Thread actuel
threading.main_thread()	Retourne l'objet Thread principal
Thread.start()	Démarre l'activité du fil
Thread.join()	Attend que le fil se termine
Thread.is_alive()	Retourne si le fil est actif
Thread.setDaemon(bool)	Définit l'indicateur démon du fil

Conclusion

Félicitations ! Vous venez de faire vos premiers pas dans le monde du threading Python. Nous avons couvert le fil principal, comment y accéder, son comportement et comment il interagit avec les autres fils. Rappelez-vous, le threading peut être un sujet complexe, mais avec de la pratique, vous vous familiariserez avec.

À mesure que nous terminons, je suis rappelé d'une citation du célèbre informaticien Alan Kay : "La meilleure façon de prédire l'avenir est de l'inventer." Avec vos nouvelles connaissances du threading Python, vous êtes maintenant équipé pour inventer des programmes multi-fils incroyables !

Continuez à coder, à apprendre, et surtout, amusez-vous ! Jusqu'à la prochaine fois, happiness threading !

Credits: Image by storyset