Wat zijn de belangrijkste IPC-mechanismen, en wanneer gebruik je welke?

Question

IT Interview Practice · Accepted Answer

Omdat elk proces een **geïsoleerde adresruimte** heeft, kunnen ze niet zomaar variabelen delen — ze hebben **inter-process communication (IPC)** nodig. Het OS biedt verschillende mechanismen, die verschillen in snelheid, richting, en of ze over machines heen werken.

## De belangrijkste mechanismen

```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
```

## Een keuze maken

- **Pipes** — simpele eenrichtings-byte streams; de ruggengraat van shell-pipelines en parent/child-plumbing.
- **Shared memory** — wanneer je **hoge throughput / lage latency** nodig hebt (bv. de shared buffers van een database). Het is het snelst omdat data niet door de kernel wordt gekopieerd — maar het biedt *geen* synchronisatie, dus je combineert het met semaforen.
- **Message queues** — wanneer je **discrete berichten** wilt met behouden grenzen en loose coupling.
- **Sockets** — het meest flexibel: **UNIX-domain sockets** op dezelfde host zijn snel; TCP/UDP-sockets werken ook **over machines heen**, en daarom gebruiken netwerkdiensten ze.
- **Signals** — voor **control**-events (interrupt, termineren, child afgesloten), niet om data te verplaatsen.

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

## Waarom het belangrijk is

IPC-keuzes bepalen de architectuur en performance van een systeem. Interviewers willen zien dat je het mechanisme aan de behoefte koppelt: shared memory voor pure snelheid (met de last van synchronisatie op de koop toe), sockets voor flexibiliteit en netwerktransparantie, pipes voor eenvoudige streaming, signals voor control. Het is de basis om te begrijpen hoe een shell-pipeline, een multi-process webserver, de shared buffers van een database, of microservices daadwerkelijk met elkaar praten.

De belangrijkste mechanismen

Een keuze maken

Waarom het belangrijk is

Gerelateerde vragen