Go ponuja dva pristopa k varnosti sočasnosti: kanali ("souporaba pomnilnika z komunikacijo") in paket sync (mutex-i/zaklj ključavnice za neposredno zaščito souporabe pomnilnika). Kljub Gove filozofiji kanaliziacije so sync primitivi pogosto preprostejša in bolj učinkovita izbira za zaščito skupne stanja.
type Counter struct {
mu sync.Mutex
count int
}
func (c *Counter) Increment() {
c.mu.Lock() // acquire the lock — only one goroutine at a time past here
defer c.mu.Unlock() // release on return (defer ensures it always happens)
c.count++ // safe — protected critical section
}
Mutex zagotavlja, da do zaščitenih podatkov dostopa le ena goroutina hkrati, kar prepreči tekmovanje za podatke. Vzorec Lock()/defer Unlock() je idiomatičen.
type Cache struct {
mu sync.RWMutex
data map[string]string
}
func (c *Cache) Get(key string) string {
c.mu.RLock() // READ lock — multiple readers allowed concurrently
defer c.mu.RUnlock()
return c.data[key]
}
func (c *Cache) Set(key, value string) {
c.mu.Lock() // WRITE lock — exclusive
defer c.mu.Unlock()
c.data[key] = value
}
RWMutex omogoča sočasno branje, vendar izključno pisanje — idealno za podatke, bogate z bralci, kot so predpomnilniki.
sync.WaitGroup // wait for a group of goroutines to finish (Add/Done/Wait)
sync.Once // run something EXACTLY once (lazy init, singletons)
var once sync.Once
once.Do(initialize) // initialize runs only on the first call, ever
sync.Map // a concurrent map (specialized cases)
atomic.AddInt64(&n, 1) // lock-free atomic operations for simple counters
Use sync (Mutex/RWMutex/atomic) when:
✓ Protecting simple shared STATE (a counter, a cache, a map)
✓ The logic is "guard this data" — locking is simpler and faster than channels here
✓ Read-heavy data (RWMutex), one-time init (Once), simple counters (atomic)
Use channels when:
✓ COMMUNICATING/passing data between goroutines, signaling, coordinating
✓ Pipelines, worker distribution, ownership transfer
Praktično pravilo: "Ne komunicirajte z souporabo pomnilnika" je smernica, ne dogma. Za preprosto zaščito skupnega stanja je mutex jasnejši in bolj učinkovit kot krčevito logiko s kanali.
Znanje, kdaj uporabiti paket sync ali kanale, je ključna značilnost zrelosti sočasnosti v Go-u.
Čeprav Go promoviramo kanale ("souporaba pomnilnika z komunikacijo"), je to le smernica — pogosta napaka pa je vsiljivanje kanalov tja, kjer bi bil preprost mutex jasnejši in hitrejši.
Paket sync je prava, idiomatična orodje za zaščito skupnega stanja (števci, predpomnilniki, zemljevidi): mutex-i za izključujoči dostop, RWMutex za podatke, bogate z bralci, WaitGroup za čakanje na goroutine, Once za enkratno inicializacijo, atomic in sync.Map za posebne primere.
Razumevanje, da kanali izstopajo pri komunikaciji in uskladitvanju, medtem ko sync primitivi izstopajo pri varovanju skupnega pomnilnika — in izbira ustreznega orodja namesto dogmatičnega uporabe kanalov — vodi do preprostejše, učinkovitejše in bolj pravilne sočasne kode.
Ta sodba je natanko tista, ki ločuje izkušene Go razvijalce, in je pogosta tema na naprednih intervjujih.
Knjižnica IT vprašanj za razgovore s podrobnimi odgovori — od začetnika do izkušenega.
Doniraj