Os seguintes métodos são comumente usados para comunicação entre processos em Python:
1. Fila (Fila) Vários processos usam filas para troca de dados. Os processos enviam e recebem objetos por meio de filas.
Uma fila é uma estrutura de dados que pode armazenar qualquer tipo de dados e suportar operações multithread.Portanto, na programação multiprocessos do Python, as filas podem ser usadas para obter comunicação entre processos.
A seguir está um exemplo de código simples que usa filas para implementar a comunicação entre processos:
import multiprocessing
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 = multiprocessing.Queue()
p1 = multiprocessing.Process(target=producer, args=(queue,))
p2 = multiprocessing.Process(target=consumer, args=(queue,))
p1.start()
p2.start()
p1.join()
queue.put(None)
p2.join()
Neste código de exemplo, definimos duas funções produtor e consumidor, que são usadas para gravar dados na fila e ler dados da fila, respectivamente. Inicializamos uma fila e então criamos dois processos p1 e p2. p1 é usado para executar a função produtora e p2 é usado para executar a função consumidora.
2. Pipe (Pipe) Pipe pode ser usado para comunicação entre processos com afinidade, como comunicação unidirecional entre dois processos.
Pipes também são um método de comunicação entre processos. Os pipes são divididos em pipes comuns (só podem ser usados entre processos pai e filho) e pipes nomeados (podem ser usados entre vários processos).
A seguir está um exemplo de código simples que usa pipes para implementar a comunicação entre processos:
import multiprocessing
def producer(pipe):
for i in range(10):
pipe.send(i)
pipe.close()
def consumer(pipe):
while True:
try:
item = pipe.recv()
print(item)
except EOFError:
break
if __name__ == '__main__':
pipe = multiprocessing.Pipe()
p1 = multiprocessing.Process(target=producer, args=(pipe[0],))
p2 = multiprocessing.Process(target=consumer, args=(pipe[1],))
p1.start()
p2.start()
p1.join()
p2.join()
Neste código de exemplo, criamos um pipeline e, em seguida, iniciamos dois processos p1 e p2. p1 é usado para executar a função produtora e p2 é usado para executar a função consumidora. Enviamos dados para o pipe na função produtora e depois fechamos o pipe; na função consumidora, continuamos a ler os dados do pipe até encontrarmos uma exceção EOFError.
3. Os processos de memória compartilhada podem definir segmentos de memória compartilhada e vários processos podem acessar o mesmo espaço de memória para obter o compartilhamento de dados. Mecanismos de sincronização como Value ou Array precisam ser usados.
A memória compartilhada é um método de comunicação entre processos muito eficiente, que permite que vários processos acessem a mesma área de memória, atingindo assim o objetivo de compartilhamento de dados.
A seguir está um exemplo de código simples que usa memória compartilhada para implementar a comunicação entre processos:
import multiprocessing
def producer(shared_value):
for i in range(10):
shared_value.value = i
def consumer(shared_value):
while True:
print(shared_value.value)
if __name__ == '__main__':
shared_value = multiprocessing.Value('i', 0)
p1 = multiprocessing.Process(target=producer, args=(shared_value,))
p2 = multiprocessing.Process(target=consumer, args=(shared_value,))
p1.start()
p2.start()
p1.join()
p2.join()
Neste código de exemplo, definimos duas funções, produtor e consumidor. A função produtor é usada para gravar dados na memória compartilhada e a função consumidor é usada para ler dados da memória compartilhada. Usamos multiprocessing.Value para criar um objeto de memória compartilhada e passá-lo para ambos os processos. Na função produtora, alteramos continuamente o valor da memória compartilhada e, na função consumidora, lemos o valor da memória compartilhada em um loop e o imprimimos.
4. Fila de mensagens (Fila de mensagens) coloca mensagens na fila por meio da interface da fila de mensagens, depois obtém a mensagem da fila e a fila passa a mensagem para outros processos.
5. Semáforo (Semáforo) é usado para transmissão de sinais entre processos e entre diferentes threads do mesmo processo, podendo enviar e receber sinais.
Os semáforos podem ser usados para controle de sincronização entre vários processos, incluindo exclusão mútua de processos e sincronização de processos.
A seguir está um exemplo de código simples que usa semáforos para implementar a comunicação entre processos:
import multiprocessing
def producer(queue, sem):
for i in range(10):
sem.acquire()
queue.put(i)
def consumer(queue, sem):
while True:
item = queue.get()
print(item)
sem.release()
if __name__ == '__main__':
queue = multiprocessing.Queue()
sem = multiprocessing.Semaphore(1)
p1 = multiprocessing.Process(target=producer, args=(queue, sem))
p2 = multiprocessing.Process(target=consumer, args=(queue, sem))
p1.start()
p2.start()
p1.join()
p2.join()
Neste código de exemplo, definimos duas funções, produtor e consumidor. A função produtor é usada para gravar dados na fila e a função consumidor é usada para ler dados da fila. Usamos multiprocessing.Semaphore para criar um semáforo e definir seu valor inicial como 1. Na função produtora, solicitamos o semáforo através do método sem.acquire(). Se for possível, escrevemos os dados na fila, caso contrário, esperamos indefinidamente; na função consumidor, lemos os dados da fila e passe sem. O método release() libera o semáforo.
6. Soquete Os processos podem se comunicar através de soquetes de rede, assim como clientes e servidores através de interfaces de rede.
Ao escolher o mecanismo de comunicação apropriado, a troca de dados e a comunicação podem ser realizadas entre processos Python. O módulo de multiprocessamento fornece vários componentes que suportam a comunicação entre processos.