Kur përdorni paketën sync në vend të channels?

Question

Accepted Answer

Go ofron dy qasje për sigurimin e konkurrencës: **channels** ("ndaj kujtesën duke komunikuar") dhe **paketën `sync`** (mutexes/locks për mbrojtjen direkte të kujtesës së ndarë). Përkundër filozofisë së Go-it të përdorimit të parë të channels, primitiva sync shpesh janë zgjedhja më e thjeshtë dhe më efikase për mbrojtjen e gjendjes së ndarë.

## sync.Mutex — mbroj gjendjen e ndarë me një bllokime

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

Një `Mutex` siguron që vetëm një goroutine të hyrë në të dhënat e mbrojtura në një kohë, duke parandaluar garat e të dhënave. Modeli `Lock()`/`defer Unlock()` është idiomatic.

## sync.RWMutex — shumë lexues OSE një shkrues

```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` lejon leximin konkurrues por shkrim ekskluziv — ideal për të dhëna me shumë lexime si cache-et.

## Primitiva të tjera sync

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

## Kur të përdorni sync kundrejt 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
```

Rregulla praktike: **"Mos komunikoni duke ndarë kujtesën" është një udhëzim, jo dogmë.** Për mbrojtjen e thjeshtë të gjendjes së ndarë, një mutex është më i qartë dhe më efikas sesa përpjekja për të shtrembëruar logjikën në channels.

## Pse ka rëndësi

Dija se kur të përdorni paketën `sync` kundrejt channels është një shenjë kyçe e pjekurisë së konkurrencës në Go.

Ndërsa Go promovohet channels ("ndaj kujtesën duke komunikuar"), ky është një udhëzim — dhe një gabim i zakonshëm është detyrimi i channels ku një **mutex** i thjeshtë do të ishte më i qartë dhe më i shpejtë.

Paketa `sync` është mjeti i duhur dhe idiomatic për **mbrojtjen e gjendjes së ndarë** (numëruesit, cache-et, maps): mutexes për hyrje ekskluzive, `RWMutex` për të dhëna me shumë lexime, `WaitGroup` për të pritur goroutines, `Once` për inicializimin e një herë, dhe `atomic`/`sync.Map` për raste të specializuara.

Kuptimi se channels bëjnë të mirë në *komunikim dhe koordinim* ndërsa primitiva sync bëjnë të mirë në *mbrojtje të kujtesës së ndarë* — dhe zgjedhja e mjetit të përshtatshëm në vend të përdorimit dogmatik të channels — çon në kod konkurrues më të thjeshtë, më efikas, më të saktë.

Ky gjykim është pikërisht ajo që dallon zhvillueset e përvojës në Go dhe është një temë e zakonshme në interview të avancuara.