Какие знаешь способы реализации межпроцессного взаимодействия?

Основные способы межпроцессного взаимодействия

Я знаю и применял в реальных проектах несколько способов реализации IPC в Python. Выбор метода зависит от требований к производительности, надежности и архитектуре системы.

1. Pipes (Каналы)

Пайпы — один из самых простых способов связи между процессами. В Python это реализуется через модуль multiprocessing:

from multiprocessing import Process, Pipe

def sender(conn):
    conn.send("Hello from process!")
    conn.close()

def receiver(conn):
    message = conn.recv()
    print(f"Received: {message}")
    conn.close()

parent_conn, child_conn = Pipe()
process = Process(target=sender, args=(child_conn,))
process.start()
receiver(parent_conn)
process.join()

Плюсы: простота, низкие накладные расходы Минусы: только двусторонняя связь между двумя процессами

2. Queues (Очереди)

Очереди лучше подходят для коммуникации между несколькими процессами:

from multiprocessing import Process, Queue

def worker(queue):
    for i in range(5):
        queue.put(f"Item {i}")

queue = Queue()
process = Process(target=worker, args=(queue,))
process.start()

while not queue.empty():
    print(queue.get())

process.join()

Плюсы: потокобезопасность, масштабируемость, FIFO порядок Минусы: немного больше накладных расходов, чем pipes

3. Shared Memory (Общая память)

Для высокопроизводительных приложений используется общая память:

from multiprocessing import Process, Value, Array
import ctypes

def modify_shared(shared_value, shared_array):
    shared_value.value = 42
    shared_array[0] = 100

shared_num = Value(ctypes.c_int, 0)
shared_arr = Array(ctypes.c_int, [1, 2, 3])

process = Process(target=modify_shared, args=(shared_num, shared_arr))
process.start()
process.join()

print(shared_num.value)  # 42
print(list(shared_arr))  # [100, 2, 3]

Плюсы: высокая производительность, быстрый доступ Минусы: необходимость синхронизации (Lock/Semaphore), сложность отладки

4. Sockets (Unix Domain Sockets и TCP/IP)

Для сетевого взаимодействия между процессами или машинами:

import socket

# TCP Socket Server
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("localhost", 5000))
server.listen(1)
conn, addr = server.accept()
data = conn.recv(1024)
conn.close()

# Client
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("localhost", 5000))
client.send(b"Hello Server")
client.close()

Плюсы: сетевая независимость, стандартный протокол Минусы: больше накладных расходов, сложнее настройка

5. Message Brokers (RabbitMQ, Redis)

Для распределенных систем с асинхронной обработкой:

import pika

# Producer
connection = pika.BlockingConnection(pika.ConnectionParameters("localhost"))
channel = connection.channel()
channel.queue_declare(queue="tasks")
channel.basic_publish(exchange="", routing_key="tasks", body="Task data")
connection.close()

# Consumer
def callback(ch, method, properties, body):
    print(f"Received: {body}")

connection = pika.BlockingConnection(pika.ConnectionParameters("localhost"))
channel = connection.channel()
channel.queue_declare(queue="tasks")
channel.basic_consume(queue="tasks", on_message_callback=callback)
channel.start_consuming()

Плюсы: надежность, масштабируемость, поддержка сложных паттернов Минусы: дополнительная инфраструктура, сложность

6. Files и Databases

Для простых случаев можно использовать файловую систему или БД:

import json
import os

# Через файлы
with open("/tmp/ipc_message.json", "w") as f:
    json.dump({"message": "Hello"}, f)

with open("/tmp/ipc_message.json", "r") as f:
    data = json.load(f)

os.remove("/tmp/ipc_message.json")

Плюсы: простота, универсальность Минусы: медленность, нет гарантий консистентности

7. gRPC и HTTP APIs

Для микросервисной архитектуры:

# gRPC пример (асинхронный RPC)
import grpc
from concurrent import futures

# Server
class GreeterServicer:
    def SayHello(self, request, context):
        return HelloReply(message=f"Hello {request.name}")

server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server.add_insecure_port("[::]:50051")
server.start()

Плюсы: языковая независимость, высокая производительность Минусы: сложность, требует дополнительного кода

Сравнение и рекомендации

В своей практике я выбираю метод на основе:

• Числа процессов — pipes для двух, queues для многих
• Требований к скорости — shared memory, если критична производительность
• Надежности — message brokers для критичных систем
• Масштабируемости — API/gRPC для микросервисов