Usando filas e pipes de multiprocessamento

Introdução

Ao trabalhar com o módulo multiprocessamento do Python, coordenar a comunicação entre processos é crucial para construir aplicativos paralelos eficientes. Neste tutorial, exploraremos a comunicação entre processos (IPC) usando filas e pipes e abordaremos objetos de memória compartilhada como uma abordagem complementar. Você aprenderá como usar essas ferramentas para trocar dados entre processos de maneira eficaz e evitar armadilhas comuns.

Filas de multiprocessamento

As filas são uma maneira segura para threads e processos de trocar dados entre processos. Elas permitem enfileirar dados em um processo e retirá-los em outro.

Exemplo: usando uma fila

import multiprocessing

def worker(q):
    # Colocar uma mensagem na fila
    q.put("Hello from worker!")

if __name__ == "__main__":
    q = multiprocessing.Queue()
    p = multiprocessing.Process(target=worker, args=(q,))
    p.start()
    # Recupere a mensagem da fila
    message = q.get()
    print("Message from worker:", message)
    p.join()

Nota

As filas lidam com a sincronização internamente, tornando-as uma escolha conveniente para comunicação entre processos sem mecanismos de bloqueio adicionais.

Pipes de multiprocessamento

Os pipes fornecem um canal de comunicação bidirecional entre dois processos. Elas são mais simples do que filas, mas são normalmente usadas para comunicação ponto a ponto.

Exemplo: usando um pipe

import multiprocessing

def worker(conn):
    # Envie uma mensagem pelo pipe
    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()
    # Receba a mensagem do pipe
    message = parent_conn.recv()
    print("Message from worker:", message)
    p.join()

Dica

Os pipes são ideais para comunicação simples e direta entre dois processos, mas para cenários mais complexos com vários produtores e consumidores, as filas são frequentemente preferíveis.

Objetos de memória compartilhada

Além de filas e pipes, o Python fornece objetos de memória compartilhada (como multiprocessing.Value e multiprocessing.Array) para compartilhar dados entre processos sem a necessidade de serialização. Isso pode reduzir a sobrecarga de comunicação.

Exemplo: usando um valor compartilhado

import multiprocessing

def increment(shared_val):
    # Use um bloqueio para evitar condições de corrida
    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)

Aviso

Ao usar objetos de memória compartilhada, sempre use bloqueios ou outros mecanismos de sincronização para evitar condições de corrida.

Conclusão

A comunicação entre processos é um aspecto fundamental da construção de aplicativos de multiprocessamento robustos. Filas e pipes fornecem maneiras diretas de trocar dados entre processos, enquanto objetos de memória compartilhada oferecem uma solução eficiente para compartilhar grandes estruturas de dados sem sobrecarga excessiva. Ao compreender e aplicar essas ferramentas, você pode projetar aplicativos Python que são eficientes e escaláveis.

Leitura adicional

• Multiprocessamento versus multithreading em Python
• Otimizando código de multiprocessamento em Python
• Solução de problemas de multiprocessamento
• Aplicativos multiprocessamento do mundo real em Python

Boa programação e que seus processos se comuniquem com eficiência!

Explore mais artigos

Nota

Aqui estão mais artigos da mesma categoria para ajudá-lo a se aprofundar no tópico.