Ce trebuie să rețineți atunci când lucrați cu…

Atunci când lucrați cu mutex-uri (sync.Mutex) în Go, este important să rețineți următoarele:

Capturarea și eliberarea: Mutex-ul trebuie neapărat să fie capturat (Lock()) înainte de a accesa datele partajate și eliberat (Unlock()) după finalizarea lucrului cu acestea. Utilizarea defer mu.Unlock() imediat după mu.Lock() este o practică bună pentru a preveni uitarea eliberării.
Acces exclusiv: Mutex-ul oferă acces exclusiv la o resursă unui singur goroutine o dată.
Starea "blocat/neblocat": Apelarea Lock() pe un mutex deja blocat va bloca goroutine-ul apelant până când altul îl va elibera. Apelarea Unlock() pe un mutex neblocat va provoca un panic în timpul execuției.
Nu copiați mutex-uri: Structura sync.Mutex nu este destinată să fie copiată după prima utilizare. Transmiterea unui mutex prin valoare sau copierea structurii care îl conține poate duce la sincronizare incorectă și panic.
Deadlocks (blocaje mortale): Apare atunci când două sau mai multe goroutine așteaptă ca celălalt să elibereze resursele. Scenariul tipic: goroutine A blochează R1 și așteaptă R2, în timp ce goroutine B blochează R2 și așteaptă R1.
Livelocks (blocaje vii): Situație în care goroutine-urile își schimbă constant starea ca răspuns la acțiunile celorlalte, fără a face muncă utilă sau a avansa. Este mai rar decât deadlock-ul.
Foame (starvation): Situație în care una sau mai multe goroutine nu pot accesa o resursă partajată din cauza faptului că este blocată constant de altele. În mutex-urile Go, foamea nu este garantată.
Utilizarea sync.RWMutex pentru citire/scriere: Dacă majoritatea operațiunilor sunt citiri și scrierile sunt rare, sync.RWMutex poate fi mai eficient. Permite mai multor goroutine să citească simultan, dar blochează în timpul unei scrieri.
Blocări scurte: Încercați să mențineți blocările cât mai scurte posibil. Cu cât mutex-ul este blocat mai mult, cu atât mai multe goroutine vor aștepta, reducând paralelismul.
Testarea condițiilor de cursă: Utilizați steagul -race la compilare și rulare teste (go test -race) pentru a detecta condiții de cursă, adesea cauzate de utilizarea incorectă a mutex-urilor.

Exemplu de utilizare a defer:

import (
	"sync"
)

type SafeCounter struct {
	mu sync.Mutex
	v  map[string]int
}

// Inc incrementează în mod sigur contorul pentru o cheie dată.
func (c *SafeCounter) Inc(key string) {
	c.mu.Lock()
	// Eliberăm la ieșirea din funcție.
	defer c.mu.Unlock()
	c.v[key]++
}

// Value returnează valoarea curentă a contorului pentru o cheie dată.
func (c *SafeCounter) Value(key string) int {
	c.mu.Lock()
	// Eliberăm după obținerea valorii.
	defer c.mu.Unlock()
	return c.v[key]
}

Ce trebuie să rețineți atunci când lucrați cu mutex-uri în Go?