Ce metode de comunicare între procese cunoști?

Canale: Principalul mod idiomatic în Go. Concurență tipizată pentru transmiterea valorilor între goroutine-uri sau procese (când se folosesc mijloace externe, precum socket-uri Unix).

// Exemplu de utilizare a unui canal pentru comunicare între goroutine-uri
ch := make(chan int)
go func() {
    ch <- 1 // trimiterea valorii
}()
value := <-ch // primirea valorii

Mutex-uri și operații atomice: Pentru protejarea datelor comune în accesul din mai multe procese.

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

Memorie partajată: Utilizarea directă poate fi dificilă de gestionat și susceptibilă la condiții de cursă. De obicei, se implementează prin alte mecanisme (de exemplu, maparea fișierelor în memorie).

Interacțiuni de rețea (TCP/UDP): Metoda clasică de comunicare între procese, mai ales pentru sistemele distribuite. Go oferă posibilități extinse pentru lucrul cu rețeaua.

// Pe partea server:
/*
   listener, _ := net.Listen("tcp", ":8080")
   conn, _ := listener.Accept()
   // citire/scriere de date prin conn
*/

// Pe partea client:
/*
   conn, _ := net.Dial("tcp", "localhost:8080")
   // citire/scriere de date prin conn
*/

Mecanisme IPC ale sistemului de operare:

• Socket-uri Unix: Mod eficient de comunicare între procese pe aceeași mașină.
• Canale numite (Pipes): Pentru comunicare unidirecțională sau bidirecțională.
• Semnale: Pentru notificări asincrone între procese.

Fișiere: Procesele pot schimba date scriind și citind din fișiere comune. Este necesar să se folosească blocări pentru a preveni condițiile de cursă.

Baze de date și brokeri de mesaje: Pentru scenarii mai complexe, comunicare asincronă și asigurarea fiabilității. Exemple: Kafka, RabbitMQ, Redis (pub/sub), PostgreSQL.