Kada naudojate sync paketą vietoje channel?

Question

Accepted Answer

Go siūlo du požiūrius į palyginamumo saugumą: **channel** ("dalintis atmintimi komunikuojant") ir **`sync` paketą** (mutex/blokavimus tiesiai saugi bendrintos atminties). Nepaisant Go channel-first filosofijos, sync primityvai dažnai yra paprastesnis ir efektyvesnis bendrintos būsenos apsaugos pasirinkimas.

## sync.Mutex — apsaugoti bendrą būseną su blokada

```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` užtikrina, kad tik vienas goroutine gali prieiti prie apsaugotų duomenų vienu metu, išvengiant duomenų lenktynių. `Lock()`/`defer Unlock()` šablonas yra idiominis.

## sync.RWMutex — daug skaitymo ARBA vienas rašymas

```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` leidžia lygiagretų skaitymą, bet ekskluyvų rašymą — idealus daugiau skaitomiem duomenims, kaip podėlis.

## Kiti sync primityvai

```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 naudoti sync vs channel

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

Praktinė taisyklė: **"Nedalinkitės atmintimi komunikuojant" yra gairė, ne dogma.** Tiesiog apsaugant bendrai būsenai, mutex yra aiškesnis ir efektyvesnis nei iškraipant logiką į channel.

## Kodėl tai svarbu

Žinoti, kada naudoti `sync` paketą, priešingai nei channel, yra ženklas Go lygiagretimo brandos.

Nors Go propaguoja channel ("dalintis atmintimi komunikuojant"), tai yra gairė — ir dažna klaida yra gaminti channel ten, kur paprastas **mutex** būtų aiškesnis ir greitesnis.

`sync` paketis yra teisinga, idiominė priemonė **bendrai būsenai apsaugoti** (skaitliams, podėliams, žemėlapiams): mutex eksklyviems prieigoms, `RWMutex` daugiau skaitomiem duomenims, `WaitGroup` goroutine patvirtinimams, `Once` vienintelei inicijalizacijai, ir `atomic`/`sync.Map` specializuotiems atvejams.

Supratimas, kad channel puikūs *komunikacijai ir koordinacijai*, o sync primityvai puikūs *bendrai atminčiai apsaugoti* — ir pasirinkti tinkamą priemonę, o ne dogmatiškai naudoti channel — veda prie paprastesnio, efektyvesnio, teisingesnio lygiagretaus kodo.

Šis sprendimas yra tiksliai tai, ką skiria patyrusieji Go programuotojai, ir yra dažnas pažangiųjų interviu klausimas.