Module queue de Python
En Python,queuele module fournit une implémentation de file d'attente thread-safe pour transmettre des données en toute sécurité dans la programmation multithread.
Une file d'attente est une structure de données de type premier entré, premier sorti (FIFO),queuele module fournit plusieurs types de files d'attente, notammentQueue、LifoQueueetPriorityQueue, pour répondre à différents besoins.
Types de files d'attente
1. Queue
QueueOuiqueueLe type de file d'attente le plus couramment utilisé dans le module, qui implémente une file d'attente FIFO (premier entré, premier sorti) standard. Ce qui suit estQueuel'utilisation de base :
Exemple
# Créer une file d'attente
q = queue.Queue()
# Ajouter des éléments à la file d'attente
q.put(1)
q.put(2)
q.put(3)
# Récupérer des éléments de la file d'attente
print(q.get()) # Sortie : 1
print(q.get()) # Sortie : 2
print(q.get()) # Sortie : 3
2. LifoQueue
LifoQueueest une file LIFO (dernier entré, premier sorti), semblable à une pile. VoiciLifoQueuel'utilisation de base :
Exemple
# Créer une file LIFO
q = queue.LifoQueue()
# Ajouter des éléments à la file d'attente
q.put(1)
q.put(2)
q.put(3)
# Récupérer des éléments de la file d'attente
print(q.get()) # Sortie : 3
print(q.get()) # Sortie : 2
print(q.get()) # Sortie : 1
3. PriorityQueue
PriorityQueueest une file de priorité où les éléments sont retirés par ordre de priorité. VoiciPriorityQueuel'utilisation de base :
Exemple
# Créer une file de priorité
q = queue.PriorityQueue()
# Ajouter des éléments à la file, les éléments sont des tuples (priorité, données)
q.put((3, 'Priorité basse'))
q.put((1, 'Priorité élevée'))
q.put((2, 'Priorité moyenne'))
# Récupérer des éléments de la file d'attente
print(q.get()) # Sortie : (1, 'High priority')
print(q.get()) # Sortie : (2, 'Medium priority')
print(q.get()) # Sortie : (3, 'Low priority')
Méthodes courantes
1. put(item, block=True, timeout=None)
vaitemPlacez dans la file. SiblockestTrueet que la file est pleine, patienteztimeoutsecondes jusqu'à ce qu'il y ait de la place libre dans la file. SitimeoutestNone, alors patientez indéfiniment.
2. get(block=True, timeout=None)
Récupérez et retirez un élément de la file. SiblockestTrueet que la file est vide, patienteztimeoutsecondes jusqu'à ce qu'il y ait un élément dans la file. SitimeoutestNone, alors patientez indéfiniment.
3. qsize()
Renvoyez le nombre d'éléments dans la file.
4. empty()
Si la file est vide, renvoyezTrue, sinon renvoyerFalse。
5. full()
Si la file d'attente est pleine, retournerTrue, sinon renvoyerFalse。
Sécurité des threads
queueTous les types de file d'attente du module sont thread-safe, ce qui signifie que plusieurs threads peuvent opérer en toute sécurité sur la même file d'attente en même temps sans mécanismes de synchronisation supplémentaires. Cela faitqueuedu module un choix idéal pour transmettre des données en programmation multithread.
Exemple : file d'attente multithread
Ce qui suit est un exemple d'utilisation deQueuepour transmettre des données entre plusieurs threads :
Exemple
import threading
import time
# Créer une file d'attente
q = queue.Queue()
# Thread producteur
def producer():
for i in range(5):
print(f'Produce {i}')
q.put(i)
time.sleep(1)
# Thread consommateur
def consumer():
while True:
item = q.get()
if item is None:
break
print(f'Consommer {item}')
q.task_done()
# Démarrer le thread producteur
producer_thread = threading.Thread(target=producer)
producer_thread.start()
# Démarrer le thread consommateur
consumer_thread = threading.Thread(target=consumer)
consumer_thread.start()
# Attendre la fin du thread producteur
producer_thread.join()
# Attendre que toutes les tâches dans la file d'attente soient terminées
q.join()
# Envoyer un signal de fin
q.put(None)
consumer_thread.join()
Attributs et méthodes courants
Ce qui suit est une description sous forme de tableau des classes, méthodes et attributs courants du module queue de Python (file d'attente thread-safe), incluant les descriptions des fonctions et des exemples :
Classes principales du module queue
| Classe | Description | Scénarios applicables |
|---|---|---|
queue.Queue | File d'attente FIFO (premier entré, premier sorti) | File d'attente de tâches générale |
queue.LifoQueue | File d'attente LIFO (dernier entré, premier sorti) (similaire à une pile) | Scénarios nécessitant un dernier entré, premier sorti |
queue.PriorityQueue | File d'attente prioritaire (implémentation par tas min) | Traiter les tâches par priorité |
queue.SimpleQueue | File d'attente FIFO plus simple (Python 3.7+) | Scénarios ne nécessitant pas de fonctionnalités avancées |
Méthodes communes (prises en charge par toutes les classes de file d'attente)
| Méthode | Description | Exemple | Valeur de retour |
|---|---|---|---|
put(item) | Ajouter un élément | q.put("task1") | Aucune |
get() | Obtenir et supprimer un élément | item = q.get() | Élément de la file d'attente |
empty() | Vérifier si la file est vide | if q.empty(): | True/False |
full() | Vérifier si la file d'attente est pleine | if q.full(): | True/False |
qsize() | Retourner la taille actuelle de la file d'attente | size = q.qsize() | Integer |
task_done() | Marquer l'achèvement d'une tâche (utilisé pourjoin()） | q.task_done() | Aucune |
join() | bloquer jusqu'à ce que toutes les tâches soient terminées | q.join() | Aucune |
Paramètres de contrôle du blocage
| Paramètre | Description | Valeur par défaut | Exemple |
|---|---|---|---|
block | Indique s'il faut bloquer lorsque la file d'attente est vide/pleine | True | q.get(block=False) |
timeout | Délai d'attente de blocage (secondes) | None | q.put(x, timeout=5) |
Utilisation spécifique de PriorityQueue
Format de l'élément :(priority, data), plus la priorité est faible, plus tôt il est retiré de la file
Exemple
pq.put((1, "low"))
pq.put((0, "high"))
print(pq.get()[1]) # Sortie : "high"
Exemple
Modèle producteur-consommateur :
Exemple
q = queue.Queue(maxsize=3) # File d'attente avec capacité 3
def producer():
for i in range(5):
q.put(f"Task-{i}")
print(f"Produit : Task-{i}")
def consumer():
while True:
item = q.get()
print(f"Consommé : {item}")
q.task_done()
threading.Thread(target=producer, daemon=True).start()
threading.Thread(target=consumer, daemon=True).start()
q.join() # Attendre que toutes les tâches soient terminées
Traitement des tâches par priorité :
Exemple
pq.put((3, "Analyse"))
pq.put((1, "Urgence"))
pq.put((2, "Journal"))
while not pq.empty():
print(pq.get()[1]) # Ordre de sortie : Urgence → Journal → Analyse
get non bloquant (pour éviter l'interblocage) :
Exemple
item = q.get_nowait() # Équivalent à q.get(block=False)
except queue.Empty:
print("La file est vide")