Wadannan zamanin da kake amfani da sync package maimakon channels?

Question

Accepted Answer

Go yana ba da hanyoyin biyu don tsaro na yau-yau: **channels** ("baje memory ta hanyar sadarwa") da **`sync` package** (mutexes/locks don kare jari da aka raba kai tsaye). Duk da falsafarar Go na channel-na-farko, sync primitives yawanci suna da sauƙi, fito masu inganci don kare jari.n da aka yi amfani.

## sync.Mutex — kare jari da aka yi amfani da lock

```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` yana tabbatar da cewa goroutine ɗaya kawai za ta iya shiga jarin da aka kare a lokaci gida, wanda hada tsayar data races. Tsarin `Lock()`/`defer Unlock()` yana da kyau.

## sync.RWMutex — karanta da yawa ko marubuci ɗaya

```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` yana ba da izinin karantaccen karanta amma karanta na yau-yau — kyau ne don bayyanar data kamar caches.

## Sauran sync primitives

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

## Wadannan zamanin da kake amfani da sync kwatai 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
```

Tsarin ta amfani: **"Kada ka sadarwa ta hanyar raba memory" shine jagora, ba dogma ba.** Don kare jarin da aka yi amfani kawai, mutex ya fi bayyana da mabambanta fiye da juyar tunani a cikin channels.

## Me ya kamata

Janewa fadada wadannan zamanin da kake amfani da `sync` package kwatai channels shi ne alamar abin amfani na yau-yau na Go.

Duk da Go ke gabawa channels ("baje memory ta hanyar sadarwa"), wannan shi ne jagora — kuma kuskure na gida shi ne tilasta channels inda mutually kawai zai kasance bayyana da mabambanta.

`sync` package shine gida, wannan shi ne gida matakin kayan aiki don **kare jarin da aka yi amfani** (lissafi, caches, maps): mutexes don amfani na yau-yau, `RWMutex` don bayyanar karanta, `WaitGroup` don jira goroutines, `Once` don ɗaya lokaci shirye-shirye, da `atomic`/`sync.Map` don siffofin musamman.

Janewa cewa channels suna siwaye a *sadarwa da daidaitawa* yayin da sync primitives suna siwaye a *gida garin jari* — da zaɓar kayan aiki da daidai maimakon amfani da channels a kai tsaye — yana haifar da sauƙi, mabambanta, daidai da yau-yau.

Wannan hanya ta yanke kunaɗi shi ne abin da ya bambanta masu gogewa Go da gida matashin bincike ta amfani.