Thread en Python

import threading
import time

# Fonction que le thread va exécuter
def afficher_message(nom: str, delai: int):
    for i in range(3):
        print(f"[{nom}] Message {i+1}")
        time.sleep(delai)
    print(f"[{nom}] Terminé !")

# Création d’un thread avec des arguments
thread1 = threading.Thread(target=afficher_message, args=("Thread-1", 1))
thread2 = threading.Thread(target=afficher_message, args=("Thread-2", 2))

# Lancement des threads
thread1.start()
thread2.start()

# Attendre la fin des threads
thread1.join()
thread2.join()

print("Tous les threads sont terminés.")

[Thread-1] Message 1
[Thread-2] Message 1
[Thread-1] Message 2
[Thread-1] Message 3
[Thread-2] Message 2
[Thread-1] Terminé !
[Thread-2] Message 3
[Thread-2] Terminé !
Tous les threads sont terminés.

Code plus "objet"

import threading
import time

class MonThread(threading.Thread):
    def __init__(self, nom: str, delai: int):
        super().__init__()
        self.nom = nom
        self.delai = delai

    def run(self):
        """Méthode exécutée automatiquement quand on lance le thread avec start()."""
        for i in range(3):
            print(f"[{self.nom}] Message {i+1}")
            time.sleep(self.delai)
        print(f"[{self.nom}] Terminé !")

# Création des threads
t1 = MonThread("Thread-1", 1)
t2 = MonThread("Thread-2", 2)

# Démarrage des threads
t1.start()
t2.start()

# Attente de leur fin
t1.join()
t2.join()

print("Tous les threads sont terminés.")

Tous les threads sont terminés.

Verrou

import threading
import time

# Compteur partagé entre threads
compteur = 0

# Création d’un verrou
verrou = threading.Lock()

class CompteurThread(threading.Thread):
    def __init__(self, nom: str, iterations: int):
        super().__init__()
        self.nom = nom
        self.iterations = iterations

    def run(self):
        global compteur
        for _ in range(self.iterations):
            # On verrouille la section critique
            with verrou:
                valeur_temp = compteur
                valeur_temp += 1
                # Simulation d’un traitement
                time.sleep(0.001)
                compteur = valeur_temp
            # On sort du "with", donc le verrou est libéré automatiquement
        print(f"{self.nom} terminé.")

# Création de plusieurs threads
threads = [CompteurThread(f"Thread-{i+1}", 1000) for i in range(5)]

# Lancement des threads
for t in threads:
    t.start()

# Attente de la fin
for t in threads:
    t.join()

print(f"Valeur finale du compteur : {compteur}")

Thread-3 terminé.
Thread-4 terminé.
Thread-5 terminé.
Valeur finale du compteur : 5000