Python Multiprocessing: 10 Ways to Perform Inter‑Process Communication

When dealing with concurrent programming and data exchange between multiple processes, Python provides several mechanisms for inter‑process communication (IPC).

1. Using Pipe for IPC:

from multiprocessing import Process, Pipe

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

def receiver(conn):
    message = conn.recv()
    print(message)
    conn.close()

if __name__ == "__main__":
    parent_conn, child_conn = Pipe()
    p1 = Process(target=sender, args=(child_conn,))
    p2 = Process(target=receiver, args=(parent_conn,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

2. Using Queue for IPC:

from multiprocessing import Process, Queue

def producer(queue):
    queue.put("Hello from producer")

def consumer(queue):
    message = queue.get()
    print(message)

if __name__ == "__main__":
    queue = Queue()
    p1 = Process(target=producer, args=(queue,))
    p2 = Process(target=consumer, args=(queue,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

3. Using Shared Memory for IPC:

from multiprocessing import Process, Value, Array

def writer(num, arr):
    num.value = 10
    for i in range(len(arr)):
        arr[i] = i

def reader(num, arr):
    print(num.value)
    print(arr[:])

if __name__ == "__main__":
    num = Value('i', 0)
    arr = Array('i', range(10))
    p1 = Process(target=writer, args=(num, arr))
    p2 = Process(target=reader, args=(num, arr))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

4. Using Manager (shared variables) for IPC:

from multiprocessing import Process, Manager

def worker(d):
    d["message"] = "Hello from worker"

if __name__ == "__main__":
    with Manager() as manager:
        d = manager.dict()
        p = Process(target=worker, args=(d,))
        p.start()
        p.join()
        print(d["message"])

5. Using Event for IPC:

from multiprocessing import Process, Event

def worker(event):
    event.wait()
    print("Event is set")

if __name__ == "__main__":
    event = Event()
    p = Process(target=worker, args=(event,))
    p.start()
    event.set()
    p.join()

6. Using Semaphore for IPC:

from multiprocessing import Process, Semaphore

def worker(semaphore):
    semaphore.acquire()
    print("Worker is running")
    semaphore.release()

if __name__ == "__main__":
    semaphore = Semaphore(1)
    p = Process(target=worker, args=(semaphore,))
    p.start()
    p.join()

7. Using Condition Variable for IPC:

from multiprocessing import Process, Condition

def producer(condition):
    with condition:
        condition.notify()
        print("Producer is running")

def consumer(condition):
    with condition:
        condition.wait()
        print("Consumer is running")

if __name__ == "__main__":
    condition = Condition()
    p1 = Process(target=producer, args=(condition,))
    p2 = Process(target=consumer, args=(condition,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

8. Using Manager‑based shared Queue for IPC:

from multiprocessing import Process, Manager

def producer(queue):
    queue.put("Hello from producer")

def consumer(queue):
    message = queue.get()
    print(message)

if __name__ == "__main__":
    with Manager() as manager:
        queue = manager.Queue()
        p1 = Process(target=producer, args=(queue,))
        p2 = Process(target=consumer, args=(queue,))
        p1.start()
        p2.start()
        p1.join()
        p2.join()

9. Using Manager‑based shared Dictionary for IPC:

from multiprocessing import Process, Manager

def worker(d):
    d["message"] = "Hello from worker"

if __name__ == "__main__":
    with Manager() as manager:
        d = manager.dict()
        p = Process(target=worker, args=(d,))
        p.start()
        p.join()
        print(d["message"])

10. Using shared Counter (Value) for IPC:

from multiprocessing import Process, Value

def worker(counter):
    with counter.get_lock():
        counter.value += 1

if __name__ == "__main__":
    counter = Value('i', 0)
    processes = [Process(target=worker, args=(counter,)) for _ in range(10)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(counter.value)

These code examples demonstrate various IPC methods, allowing you to select the most suitable approach for your specific multi‑process data exchange and collaboration needs.