Python - Priorité des Thread

Bonjour, aspirants programmeurs ! Aujourd'hui, nous allons plonger dans un sujet passionnant de la programmation Python : la priorité des threads. En tant que votre enseignant en informatique de quartier, je suis là pour vous guider à travers ce voyage, étape par étape. 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 partons ensemble dans cette aventure Python !

Comprendre les Threads et la Priorité

Avant de plonger dans les détails de la priorité des threads, prenons un moment pour comprendre ce que sont les threads. Imaginez-vous dans une cuisine occupée et que vous êtes le chef principal. Vous avez plusieurs tâches à accomplir : hacher des légumes, remuer la soupe et faire un gâteau. Au lieu de faire ces tâches l'une après l'autre, vous assignez différents chefs (threads) pour travailler sur ces tâches simultanément. C'est essentiellement ce que font les threads en programmation – ils permettent à un programme de réaliser plusieurs tâches concurremment.

Maintenant, la priorité des threads est comme assigner de l'importance à ces tâches. Juste comme vous pourriez prioriser la préparation du plat principal avant le dessert, vous pouvez prioriser certains threads dans votre programme Python.

Définir la Priorité des Thread Using Sleep()

Un moyen simple d'influer sur la priorité des threads en Python est d'utiliser la fonction sleep(). Bien que cette méthode ne définisse pas directement la priorité, elle peut aider à gérer le temps d'exécution des différents threads.

Regardons un exemple :

import threading
import time

def tâche(nom, sleep_time):
print(f"Tâche {nom} commencée")
time.sleep(sleep_time)
print(f"Tâche {nom} terminée")

# Créer des threads
thread1 = threading.Thread(target=tâche, args=("A", 2))
thread2 = threading.Thread(target=tâche, args=("B", 1))

# Démarrer les threads
thread1.start()
thread2.start()

# Attendre que les threads se terminent
thread1.join()
thread2.join()

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

Dans cet exemple, nous créons deux threads qui exécutent la fonction tâche. La tâche A dort pendant 2 secondes, tandis que la tâche B dort pendant 1 seconde. Même si nous commençons la tâche A en premier, la tâche B se terminera probablement en premier en raison de son temps de sommeil plus court.

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

Tâche A commencée
Tâche B commencée
Tâche B terminée
Tâche A terminée
Toutes les tâches sont terminées

Ceci montre comment nous pouvons influencer l'ordre et la durée d'exécution des threads en utilisant sleep().

Ajuster la Priorité des Thread Python sur Windows

Sur les systèmes Windows, Python nous permet de définir la priorité des threads plus directement. Nous pouvons utiliser le module win32process du package pywin32 pour ajuster les priorités des threads.

Tout d'abord, vous devez installer pywin32 :

pip install pywin32

Maintenant, regardons un exemple :

import threading
import time
import win32api
import win32process
import win32con

def set_thread_priority(priority):
handle = win32api.GetCurrentThread()
win32process.SetThreadPriority(handle, priority)

def tâche(nom, priority):
set_thread_priority(priority)
print(f"Tâche {nom} commencée avec priorité {priority}")
time.sleep(2)
print(f"Tâche {nom} terminée")

# Créer des threads
thread1 = threading.Thread(target=tâche, args=("A", win32process.THREAD_PRIORITY_BELOW_NORMAL))
thread2 = threading.Thread(target=tâche, args=("B", win32process.THREAD_PRIORITY_ABOVE_NORMAL))

# Démarrer les threads
thread1.start()
thread2.start()

# Attendre que les threads se terminent
thread1.join()
thread2.join()

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

Dans cet exemple, nous définissons la tâche A avec une priorité inférieure et la tâche B avec une priorité supérieure. Le système d'exploitation Windows essaiera d'allouer plus de temps CPU à la tâche B, potentially causing it to complete faster.

Prioriser les Threads Python Using le Module Queue

Un autre moyen de gérer les priorités des threads est d'utiliser le module Queue de Python. Bien que cela ne définisse pas directement les priorités, il permet de contrôler l'ordre dans lequel les tâches sont traitées.

Voici un exemple :

import threading
import queue
import time

def worker(q, name):
while True:
task = q.get()
if task is None:
break
print(f"Worker {name} processing task: {task}")
time.sleep(1)
q.task_done()

# Créer une file de priorité
q = queue.PriorityQueue()

# Ajouter des tâches à la file (nombre inférieur = priorité supérieure)
q.put((2, "Tâche de basse priorité"))
q.put((1, "Tâche de haute priorité"))
q.put((3, "Tâche de plus basse priorité"))

# Créer et démarrer les threads de travail
threads = []
for i in range(2):
t = threading.Thread(target=worker, args=(q, i))
t.start()
threads.append(t)

# Attendre que toutes les tâches soient terminées
q.join()

# Arrêter les travailleurs
for i in range(2):
q.put(None)

for t in threads:
t.join()

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

Dans cet exemple, nous utilisons une PriorityQueue pour gérer les tâches. Les tâches avec des nombres inférieurs sont traitées en premier. Cela permet de prioriser certaines tâches par rapport à d'autres.

Conclusion

Et voilà, mes chers étudiants ! Nous avons exploré trois différentes manières de gérer les priorités des threads en Python. Rappelez-vous, comme dans une cuisine bien orchestrée, la gestion des priorités des threads aide votre programme à fonctionner plus efficacement.

Voici un résumé rapide des méthodes que nous avons couvertes :

Méthode	Pros	Cons
Utiliser sleep()	Simple à mettre en œuvre	Ne défini pas directement la priorité
Priorité spécifique à Windows	Contrôle direct sur la priorité des threads	Ne fonctionne que sur les systèmes Windows
Module Queue	Fonctionne sur tous les systèmes, permet un contrôle fin	Nécessite une implémentation plus complexe

À mesure que vous continuez votre voyage Python, vous découvrirez que comprendre les priorités des threads peut être extrêmement utile pour optimiser vos programmes. Continuez à pratiquer, restez curieux et n'ayez pas peur d'expérimenter. Bon codage !

Credits: Image by storyset