Kada koristiš sync paket umjesto channels?

Question

Accepted Answer

Go nudi dva pristupa konkurentnoj sigurnosti: **channels** ("dijeljenje memorije komunikacijom") i **`sync` paket** (muteksi/brava za zaštitu dijeljene memorije izravno). Unatoč Go-ovoj filozofiji kanala u prvi plan, sync primitivci su često jednostavniji i učinkovitiji izbor za zaštitu dijeljenog stanja.

## sync.Mutex — zaštita dijeljenog stanja s bravom

```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` osigurava da samo jedna goroutina pristupa zaštićenim podacima u istom trenutku, sprječavajući race conditions. Obrazac `Lock()`/`defer Unlock()` je idiomatičan.

## sync.RWMutex — mnogo čitatelja ILI jedan pisac

```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` omogućuje konkurentno čitanje, ali ekskluzivno pisanje — idealno za podatke s puno čitanja kao što su cachei.

## Ostali sync primitivci

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

## Kada koristiti sync umjesto channels

```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 komuniciraj dijeljenjem memorije" je smjernica, ne dogma.** Za samo zaštitu dijeljenog stanja, mutex je jasniji i učinkovitiji nego savijanje logike u channels.

## Zašto je važno

Znanje kada koristiti `sync` paket naspram channels je ključan pokazatelj zrelosti u Go konkurentnosti.

Iako Go promovira channels ("dijeljenje memorije komunikacijom"), ovo je smjernica — i česta greška je forsiranje channels gdje bi jednostavan **mutex** bio jasniji i brži.

`sync` paket je ispravan, idiomatičan alat za **zaštitu dijeljenog stanja** (brojači, cachei, mape): muteksi za ekskluzivan pristup, `RWMutex` za podatke s puno čitanja, `WaitGroup` za čekanje na goroutine, `Once` za inicijalizaciju samo jednom, i `atomic`/`sync.Map` za specijalizirane slučajeve.

Razumijevanje da channels izvrsno služe za *komunikaciju i koordinaciju* dok sync primitivci izvrsno služe za *čuvanje dijeljene memorije* — i odabir odgovarajućeg alata umjesto dogmatskog korištenja channels — vodi do jednostavnijeg, učinkovitijeg i ispravnijeg konkurentnog koda.

Ova prosudba je upravo ono što razlikuje iskusne Go programere i česta je napredna tema na razgovorima za posao.