Was sind die wichtigsten IPC-Mechanismen und wann verwendest du welchen?

Question

IT Interview Practice · Accepted Answer

Weil jeder Prozess einen **isolierten Adressraum** hat, können sie nicht einfach Variablen teilen — sie brauchen **Inter-Process Communication (IPC)**. Das OS bietet mehrere Mechanismen, die sich in Geschwindigkeit, Richtung und darin unterscheiden, ob sie über Maschinen hinweg funktionieren.

## Die wichtigsten 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
```

## Einen auswählen

- **Pipes** — einfache Einweg-Byte-Streams; das Rückgrat von Shell-Pipelines und Parent/Child-Verrohrung.
- **Shared Memory** — wenn du **hohen Throughput / niedrige Latenz** brauchst (z. B. die Shared Buffers einer Datenbank). Es ist am schnellsten, weil Daten nicht durch den Kernel kopiert werden — aber es bietet *keine* Synchronisation, daher kombinierst du es mit Semaphoren.
- **Message Queues** — wenn du **diskrete Nachrichten** mit erhaltenen Grenzen und loser Kopplung willst.
- **Sockets** — die flexibelsten: **UNIX-Domain-Sockets** auf demselben Host sind schnell; TCP/UDP-Sockets funktionieren auch **über Maschinen hinweg**, weshalb vernetzte Dienste sie verwenden.
- **Signals** — für **Steuerungsereignisse** (Interrupt, Terminate, Child beendet), nicht zum Bewegen von Daten.

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

## Warum es wichtig ist

IPC-Entscheidungen formen die Architektur und Performance eines Systems. Interviewer wollen sehen, dass du den Mechanismus an den Bedarf anpasst: Shared Memory für rohe Geschwindigkeit (die Last der Synchronisation in Kauf nehmend), Sockets für Flexibilität und Netzwerktransparenz, Pipes für einfaches Streaming, Signals für Steuerung. Es ist die Grundlage, um zu verstehen, wie eine Shell-Pipeline, ein Multi-Prozess-Webserver, die Shared Buffers einer Datenbank oder Microservices tatsächlich miteinander sprechen.

Die wichtigsten Mechanismen

Einen auswählen

Warum es wichtig ist

Ähnliche Fragen