sync paketini kanallar yerine ne zaman kullanırsınız?

Question

Accepted Answer

Go eşzamanlılık güvenliği için iki yaklaşım sunar: **kanallar** ("belleği iletişimle paylaş") ve **`sync` paketi** (paylaşılan belleği doğrudan koruyan muteksler/kilitler). Go'nun kanal önceliğine rağmen, sync ilkeleri genellikle paylaşılan durumu korumanın daha basit, daha verimli seçeneğidir.

## sync.Mutex — paylaşılan durumu bir kilit ile koru

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

Bir `Mutex`, korunan verilere aynı anda yalnızca bir goroutine'in erişmesini sağlar ve veri yarışlarını engeller. `Lock()`/`defer Unlock()` deseni idiomatiktir.

## sync.RWMutex — çok sayıda okuyucu VEYA bir yazıcı

```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` eşzamanlı okumalara izin verir ancak yazmaları özel hale getirir — önbellekler gibi okuma yoğun veriler için ideal.

## Diğer sync ilkeleri

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

## sync vs kanallar kullanımı

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

Praktik kural: **"Belleği paylaşarak iletişim kurmayın" bir rehberdir, dogma değildir.** Basit paylaşılan durumu korumak için, bir mutex mantığı kanallara çeviştirmekten daha açık ve daha verimlidir.

## Neden önemli

`sync` paketinin kanallara karşı ne zaman kullanılacağını bilmek, Go eşzamanlılık olgunluğunun önemli bir işaretidir.

Go'nun kanalları tanıtması ("belleği iletişimle paylaş") bir rehber olsa da, bu bir rehberdir — ve yaygın bir hata, basit bir **mutex** daha açık ve hızlı olacağı yerlerde kanallara zorlanmasıdır.

`sync` paketi, **paylaşılan durumu korumak** için (sayaçlar, önbellekler, haritalar) doğru, idiomatik araçtır: özel erişim için muteksler, okuma yoğun veriler için `RWMutex`, goroutine'ler üzerinde bekleme için `WaitGroup`, tek seferlik başlatma için `Once`, ve özel durumlar için `atomic`/`sync.Map`.

Kanalların *iletişim ve koordinasyon* konusunda mükemmel olduğunu ve sync ilkellerinin *paylaşılan belleği koruma* konusunda mükemmel olduğunu anlamak — ve dogmatik olarak kanalları kullanmak yerine uygun aracı seçmek — daha basit, daha verimli, daha doğru eşzamanlı koda yol açar.

Bu yargı, deneyimli Go geliştiricileri ayıran ve sık görülen ileri düzey mülakat konusudur.