Welke communicatie tussen processen ken je?

Kanalen: De belangrijkste idiomatische manier in Go. Getypte concurrency voor het overdragen van waarden tussen goroutines of processen (bij gebruik van externe middelen zoals Unix-sockets).

// Voorbeeld van het gebruik van een kanaal voor communicatie tussen goroutines
ch := make(chan int)
go func() {
    ch <- 1 // waarde verzenden
}()
value := <-ch // waarde ontvangen

Mutexen en atomische operaties: Om gedeelde gegevens te beschermen bij toegang vanuit meerdere processen.

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)
}

Gedeeld geheugen: Het direct gebruiken kan moeilijk te beheren zijn en is gevoelig voor racecondities. Wordt meestal geïmplementeerd via andere mechanismen (bijvoorbeeld geheugenmapping van bestanden).

Netwerkinteracties (TCP/UDP): Klassieke methode voor interprocescommunicatie, vooral voor gedistribueerde systemen. Go biedt uitgebreide mogelijkheden voor netwerkwerking.

// Aan de serverzijde:
/*
   listener, _ := net.Listen("tcp", ":8080")
   conn, _ := listener.Accept()
   // lezen/schrijven van gegevens via conn
*/

// Aan de clientzijde:
/*
   conn, _ := net.Dial("tcp", "localhost:8080")
   // lezen/schrijven van gegevens via conn
*/

IPC-mechanismen van het OS:

• Unix-domein sockets: Efficiënte manier om processen op dezelfde machine te laten communiceren.
• Genummerde pipes: Voor unidirectionele of bidirectionele communicatie.
• Signalen: Voor asynchrone meldingen tussen processen.

Bestanden: Processen kunnen gegevens uitwisselen door te schrijven en te lezen uit gedeelde bestanden. Locking is nodig om racecondities te voorkomen.

Databases en berichtbrokers: Voor complexere scenario's, asynchrone communicatie en betrouwbaarheid. Voorbeelden: Kafka, RabbitMQ, Redis (pub/sub), PostgreSQL.