What are the main IPC mechanisms, and when do you use each?

Question

IT Interview Practice · Accepted Answer

Because each process has an **isolated address space**, they can't just share variables — they need **inter-process communication (IPC)**. The OS offers several mechanisms, differing in speed, direction, and whether they work across machines.

## The main mechanisms

```text
Pipe / FIFO      → byte stream, one direction; anonymous pipe = parent↔child, named FIFO = any procs
                   e.g.  ls | grep foo   (the shell wires stdout→stdin via a pipe)
Shared memory    → both map the SAME physical pages → FASTEST (no copy), but you must
                   synchronize access yourself (semaphore/mutex)
Message queue    → kernel-managed queue of discrete messages; decoupled, preserves boundaries
Socket           → bidirectional stream/datagram; UNIX-domain (same host) or TCP/UDP (across network)
Signal           → tiny async notification (a number), e.g. SIGINT, SIGTERM — control, not data transfer
```

## Choosing one

- **Pipes** — simple one-way byte streams; the backbone of shell pipelines and parent/child plumbing.
- **Shared memory** — when you need **high throughput / low latency** (e.g. a database's shared buffers). It's the fastest because data isn't copied through the kernel — but it offers *no* synchronization, so you pair it with semaphores.
- **Message queues** — when you want **discrete messages** with preserved boundaries and loose coupling.
- **Sockets** — the most flexible: same-host **UNIX-domain sockets** are fast; TCP/UDP sockets also work **across machines**, which is why networked services use them.
- **Signals** — for **control** events (interrupt, terminate, child exited), not for moving data.

```text
        copy through kernel                          no copy
  slower ◀─────────────────────────────────────────────▶ faster
  socket / message queue / pipe            shared memory (+ your own locking)
```

## Why it matters

IPC choices shape a system's architecture and performance. Interviewers want to see you match the mechanism to the need: shared memory for raw speed (accepting the burden of synchronization), sockets for flexibility and network transparency, pipes for simple streaming, signals for control. It's the foundation for understanding how a shell pipeline, a multi-process web server, a database's shared buffers, or microservices actually talk to each other.

The main mechanisms

Choosing one

Why it matters

Related questions