Utilisation des files d’attente et des tuyaux en multiprocessus

Introduction

Lorsque l’on travaille avec le module multiprocessus de Python, la coordination de la communication entre les processus est cruciale pour construire des applications parallèles efficaces. Dans ce tutoriel, nous explorerons la communication interprocessus (IPC) à l’aide des files d’attente et des tuyaux, et nous aborderons les objets à mémoire partagée en tant qu’approche complémentaire. Vous apprendrez à utiliser ces outils pour échanger efficacement des données entre processus et éviter les pièges les plus courants.

Files d’attente multiprocessus

Les files d’attente sont un moyen sûr pour les threads et les processus d’échanger des données entre les processus. Elles vous permettent de mettre en file d’attente des données dans un processus et de les mettre en file d’attente dans un autre processus.

Exemple : utilisation d’une file d’attente Utilisation d’une file d’attente

import multiprocessing

def worker(q):
    # Placer un message dans la file d'attente
    q.put("Hello from worker!")

if __name__ == "__main__":
    q = multiprocessing.Queue()
    p = multiprocessing.Process(target=worker, args=(q,))
    p.start()
    # Récupérer le message dans la file d'attente
    message = q.get()
    print("Message from worker:", message)
    p.join()

Note

Les files d’attente gèrent la synchronisation en interne, ce qui en fait un choix pratique pour la communication inter-processus sans mécanismes de verrouillage supplémentaires.

Pipes multiprocesseurs

Les tuyaux fournissent un canal de communication bidirectionnel entre deux processus. Les files d’attente sont plus simples que les files d’attente mais sont généralement utilisées pour la communication point à point.

Exemple : Utilisation d’un tuyau

import multiprocessing

def worker(conn):
    # Envoi d'un message par l'intermédiaire du tuyau
    conn.send("Hello from worker!")
    conn.close()

if __name__ == "__main__":
    parent_conn, child_conn = multiprocessing.Pipe()
    p = multiprocessing.Process(target=worker, args=(child_conn,))
    p.start()
    # Recevoir le message du tuyau
    message = parent_conn.recv()
    print("Message from worker:", message)
    p.join()

Astuce

Les tuyaux sont idéaux pour une communication simple et directe entre deux processus, mais pour des scénarios plus complexes avec de multiples producteurs et consommateurs, les files d’attente sont souvent préférables.

Objets à mémoire partagée

Outre les files d’attente et les tuyaux, Python propose des objets de mémoire partagée (tels que multiprocessing.Value et multiprocessing.Array) pour partager des données entre les processus sans avoir recours à la sérialisation. Cela peut réduire les frais généraux de communication.

Exemple : Utilisation d’une valeur partagée

import multiprocessing

def increment(shared_val):
    # Utiliser un verrou pour éviter les conditions de course
    with shared_val.get_lock():
        shared_val.value += 1

if __name__ == "__main__":
    shared_val = multiprocessing.Value('i', 0)
    processes = []
    for _ in range(5):
        p = multiprocessing.Process(target=increment, args=(shared_val,))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()
    print("Final value:", shared_val.value)

Avertissement

Lorsque vous utilisez des objets à mémoire partagée, utilisez toujours des verrous ou d’autres mécanismes de synchronisation pour éviter les conditions de course.

Conclusion

La communication inter-processus est un aspect essentiel de la construction d’applications multiprocessus robustes. Les files d’attente et les tuyaux constituent des moyens simples d’échanger des données entre processus, tandis que les objets à mémoire partagée offrent une solution efficace pour partager de grandes structures de données sans surcharge excessive. En comprenant et en appliquant ces outils, vous pouvez concevoir des applications Python qui sont à la fois efficaces et évolutives.

Plus d’informations

• Multiprocessing vs. Multithreading en Python
• Optimisation du code multiprocesseur en Python
• Résolution des problèmes liés au multiprocessus
• Applications multiprocessus du monde réel en Python

Un bon codage, et que vos processus communiquent efficacement!

Explorer d’autres articles

Note

Voici d’autres articles de la même catégorie pour vous aider à approfondir le sujet.