Kdaj uporabite paket sync namesto kanalov?

Question

Accepted Answer

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.

## sync.Mutex — zaščitite skupno stanje s ključavnico

```go
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.

## sync.RWMutex — mnogo bralcev ALI en pisec

```go
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.

## Drugi sync primitivi

```go
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
```

## Kdaj uporabiti sync ali kanale

```text
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.

## Zakaj je to pomembno

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.