Welche Kommunikationsmethoden zwischen Prozessen kennst du?

Kanäle: Die idiomatische Hauptmethode in Go. Typisierte Concurrenzen zum Übertragen von Werten zwischen Goroutines oder Prozessen (bei Verwendung externer Mittel wie Unix-Sockets).

// Beispiel für die Verwendung eines Kanals zur Kommunikation zwischen Goroutines
ch := make(chan int)
go func() {
    ch <- 1 // Wert senden
}()
value := <-ch // Wert empfangen

Mutexe und atomare Operationen: Zum Schutz gemeinsamer Daten beim Zugriff aus mehreren Prozessen.

import (
    "sync"
    "sync/atomic"
)

var mu sync.Mutex
var counter int

func incrementWithMutex() {
    mu.Lock()
    counter++
    mu.Unlock()
}

var atomicCounter int32

func incrementWithAtomic() {
    atomic.AddInt32(&atomicCounter, 1)
}

Gemeinsam genutzter Speicher: Bei direkter Nutzung kann schwierig zu verwalten sein und ist anfällig für Race Conditions. Wird meist durch andere Mechanismen realisiert (z.B. Memory-Mapping von Dateien).

Netzwerkinteraktionen (TCP/UDP): Klassischer Weg der interprozessualen Kommunikation, besonders für verteilte Systeme. Go bietet umfangreiche Möglichkeiten für die Netzwerkarbeit.

// Serverseitig:
/*
   listener, _ := net.Listen("tcp", ":8080")
   conn, _ := listener.Accept()
   // Lesen/Schreiben von Daten über conn
*/

// Clientseitig:
/*
   conn, _ := net.Dial("tcp", "localhost:8080")
   // Lesen/Schreiben von Daten über conn
*/

Betriebssystem-IPC-Mechanismen:

• Unix-Domain-Sockets: Effiziente Methode zur Kommunikation zwischen Prozessen auf derselben Maschine.
• Benannte Pipes: Für unidirektionale oder bidirektionale Kommunikation.
• Signale: Für asynchrone Benachrichtigungen zwischen Prozessen.

Dateien: Prozesse können Daten austauschen, indem sie in gemeinsam genutzte Dateien schreiben und daraus lesen. Es sind Sperren notwendig, um Race Conditions zu vermeiden.

Datenbanken und Nachrichtenbroker: Für komplexere Szenarien, asynchrone Kommunikation und Zuverlässigkeit. Beispiele: Kafka, RabbitMQ, Redis (pub/sub), PostgreSQL.