Tutoriel d'interaction de données multi-processus Python

Tutoriel d'interaction de données multi-processus Python

Introduction

En Python, le multi-traitement est une méthode de traitement parallèle, qui peut améliorer l'efficacité d'exécution du programme. Cependant, l'interaction des données entre plusieurs processus est un problème courant. Ce didacticiel présentera comment réaliser une interaction de données entre plusieurs processus en Python.

1. Mémoire partagée

La mémoire partagée est un moyen courant d'interaction de données entre plusieurs processus. En Python, vous pouvez utiliser multiprocessing.Valueet multiprocessing.Arraypour créer de la mémoire partagée.

1.1 utilisationmultiprocessing.Value

multiprocessing.ValuePeut être utilisé pour créer une variable numérique partagée.

from multiprocessing import Process, Value

def increment(counter):
    counter.value += 1

if __name__ == '__main__':
    counter = Value('i', 0)
    processes = [Process(target=increment, args=(counter,)) for _ in range(10)]
    
    for p in processes:
        p.start()
    
    for p in processes:
        p.join()
    
    print(counter.value)  # 输出结果为 10

1.2 utilisationmultiprocessing.Array

multiprocessing.ArrayPeut être utilisé pour créer un tableau partagé.

from multiprocessing import Process, Array

def increment(arr):
    for i in range(len(arr)):
        arr[i] += 1

if __name__ == '__main__':
    arr = Array('i', [0, 0, 0, 0, 0])
    processes = [Process(target=increment, args=(arr,)) for _ in range(10)]
    
    for p in processes:
        p.start()
    
    for p in processes:
        p.join()
    
    print(arr[:])  # 输出结果为 [10, 10, 10, 10, 10]

2. File d'attente

Les files d'attente sont un autre moyen d'interaction de données entre plusieurs processus. En Python, vous pouvez utiliser multiprocessing.Queuepour créer une file d'attente.

from multiprocessing import Process, Queue

def producer(queue):
    for i in range(10):
        queue.put(i)

def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(item)

if __name__ == '__main__':
    queue = Queue()
    producer_process = Process(target=producer, args=(queue,))
    consumer_process = Process(target=consumer, args=(queue,))
    
    producer_process.start()
    consumer_process.start()
    
    producer_process.join()
    queue.put(None)
    consumer_process.join()

3. Canalisation

Les pipelines sont un autre moyen d'échanger des données entre plusieurs processus. En Python, vous pouvez utiliser multiprocessing.Pipepour créer un pipeline.

from multiprocessing import Process, Pipe

def sender(conn):
    conn.send('Hello from sender')
    conn.close()

def receiver(conn):
    msg = conn.recv()
    print('Received:', msg)
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    sender_process = Process(target=sender, args=(child_conn,))
    receiver_process = Process(target=receiver, args=(parent_conn,))
    
    sender_process.start()
    receiver_process.start()
    
    sender_process.join()
    receiver_process.join()

en conclusion

Ce didacticiel présente plusieurs méthodes courantes pour réaliser une interaction de données entre plusieurs processus en Python, notamment la mémoire partagée, les files d'attente et les pipelines. Selon les besoins spécifiques, le choix de la méthode appropriée peut améliorer l'efficacité et la maintenabilité du programme.