Harici yazma sırasında hatalardan nasıl korunuruz…

Golang'da map üzerinde eşzamanlı yazma sırasında oluşabilecek hatalara karşı koruma sağlamak için, varsayılan olarak çok iş parçacığı güvenli olmayan aşağıdaki mekanizmalar kullanılır:

sync.Mutex: map'i yazmadan önce kilitler ve sonra serbest bırakır.

import "sync"

type SafeMap struct {
    mu sync.Mutex
    data map[string]int
}

func NewSafeMap() *SafeMap {
    return &SafeMap{
        data: make(map[string]int),
    }
}

func (sm *SafeMap) Set(key string, value int) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMap) Get(key string) (int, bool) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.RWMutex: Birden fazla goroutine'un aynı anda map'i okuyabilmesine izin verir, ancak eşzamanlı okuma veya yazma sırasında kilitler.

import "sync"

type SafeMapRWMutex struct {
    mu sync.RWMutex
    data map[string]int
}

func NewSafeMapRWMutex() *SafeMapRWMutex {
    return &SafeMapRWMutex{
        data: make(map[string]int),
    }
}

func (sm *SafeMapRWMutex) Set(key string, value int) {
    sm.mu.Lock() // Yazma kilidi
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMapRWMutex) Get(key string) (int, bool) {
    sm.mu.RLock() // Okuma kilidi
    defer sm.mu.RUnlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.Map: Belirli senaryolar için optimize edilmiş, çok iş parçacığı güvenli özel bir türdür. Anahtar kümesi görece stabildir ve yazma işlemleri nadirdir veya farklı goroutine'lerin okuma ve yazma yaptığı durumlar için uygundur.

import "sync"

var safeMap sync.Map // Deklarasyon

func UseSyncMap() {
    safeMap.Store("key1", 10) // Yazma
    if val, ok := safeMap.Load("key1"); ok { // Okuma
        // val kullan
    }
    safeMap.Delete("key1") // Silme
}

Yaklaşımların karşılaştırması:

Mekanizma	Avantajlar	Dezavantajlar	Uygulama
`sync.Mutex`	Kullanımı basit	Yazma sırasında tüm işlemleri engeller	Düşük eşzamanlılık veya okuma/yazma oranlarının yaklaşık eşit olduğu basit senaryolar.
`sync.RWMutex`	Paralel okuma sağlar	`sync.Mutex`'ten daha karmaşık. Yazma, okuma ve diğer yazma işlemlerini engeller.	Sık okuma ve nadir yazma senaryoları.
`sync.Map`	Belirli senaryolar için optimize edilmiş	Sınırlı API'ye sahiptir. Rastgele erişimde `Mutex`'ten daha yavaş olabilir.	Görece stabil anahtarlar veya farklı goroutine'ler için disjunkt anahtar kümeleri içeren senaryolar.

Belirli bir yaklaşımın seçimi, map'e erişim şekline bağlıdır. Genel durumlar için genellikle sync.Mutex veya sync.RWMutex yeterlidir. Özel durumlar için sync.Map daha iyi performans sağlayabilir.

Harici yazma sırasında hatalardan nasıl korunuruz?