Çalıştırılabilir Go Dokümanları: Mutex

Q: Go'da mutex nedir?

Bir sync.Mutex, mu.Lock() ile mu.Unlock() arasındaki kodu aynı anda yalnızca bir goroutine'in çalıştırmasına izin veren bir kilittir. Onu bir map ya da bir struct gibi birkaç goroutine'in okuyup yazdığı veriyi korumak için kullanırsınız. Sıfır değeri kilitli olmayan, kullanıma hazır bir mutex'tir.

Q: Go'da sync.Mutex yeniden girilebilir (reentrant) mi?

Hayır. Kilidi tutan bir goroutine Lock'u yeniden çağırırsa kendini bekleyerek sonsuza kadar bloklanır. Kodu, dışa açık metotların kilidi alıp kilidin zaten tutulduğunu varsayan dışa kapalı yardımcıları çağıracağı şekilde yapılandırın.

Paylaşılan veriyi korumak

Bir sync.Mutex, Lock ile Unlock arasındaki koda aynı anda yalnızca bir goroutine'in girmesine izin verir. Mutex'i koruduğu verinin yanına, genellikle aynı struct'a koyun:

package main

import (
	"fmt"
	"sync"
)

type Counter struct {
	mu     sync.Mutex
	counts map[string]int
}

func (c *Counter) Inc(key string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.counts[key]++
}

func (c *Counter) Get(key string) int {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.counts[key]
}

func main() {
	c := Counter{counts: make(map[string]int)}

	var wg sync.WaitGroup
	for range 100 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for range 100 {
				c.Inc("hits")
			}
		}()
	}
	wg.Wait()

	fmt.Println("hits:", c.Get("hits"))
}

Bu her zaman hits: 10000 yazdırır. Kilit olmadan aynı map'e yazan 100 goroutine programı genellikle fatal error: concurrent map writes ile çökertirdi. Bu hata çalışma zamanındaki elden geldiğince yapılan bir kontrolden gelir, recover edilemez ve çökmemesi kodun doğru olduğunu kanıtlamaz.

Önemli ayrıntılar:

sync.Mutex'in sıfır değeri kilitli değildir ve hazırdır. Kurucu yoktur.
Metotlar pointer alıcı (*Counter) kullanır. Değer alıcı mutex'in bir kopyasını kilitlerdi ve bu hiçbir şeyi korumaz.
Lock'tan hemen sonra defer c.mu.Unlock(), her dönüş yolunun ve bir panic'in kilidi bırakması anlamına gelir.
Okumalar dahil her erişim kilitten geçer. Başka bir goroutine yazarken kilitsiz bir okuma yine de bir data race'tir.

Kritik bölümü küçük tutun

defer fonksiyonun sonunda kilidi açar. Bu, yukarıdakiler gibi kısa metotlar için doğrudur. Daha uzun bir fonksiyonda paylaşılan veriye artık dokunulmadığı anda kilidi açın, böylece diğer goroutine'ler kilide ihtiyaç duymayan işi beklemez:

func (s *Store) Save(key string) error {
	s.mu.Lock()
	data := s.items[key] // copy what you need
	s.mu.Unlock()

	return writeToDisk(key, data) // slow I/O, outside the lock
}

Ağ çağrıları, disk G/Ç'si ya da bir channel gönderimi boyunca kilit tutmak yavaş bir eşzamanlı programın en yaygın nedenidir; kilit altında bir channel gönderimi ise deadlock'un yaygın bir nedenidir.

Okuma ağırlıklı veri için RWMutex

sync.RWMutex'in iki modu vardır. RLock/RUnlock, birçok goroutine'in aynı anda tutabileceği paylaşılan bir okuma kilidi alır. Lock/Unlock ise tüm okuyucular çıkana kadar bekleyen özel yazma kilidini alır.

package main

import (
	"fmt"
	"sync"
)

type Config struct {
	mu     sync.RWMutex
	values map[string]string
}

func (c *Config) Get(key string) (string, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	v, ok := c.values[key]
	return v, ok
}

func (c *Config) Set(key, value string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.values[key] = value
}

func main() {
	cfg := &Config{values: map[string]string{"mode": "dev"}}

	var wg sync.WaitGroup
	for range 50 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			cfg.Get("mode") // many readers at the same time
		}()
	}
	wg.Add(1)
	go func() {
		defer wg.Done()
		cfg.Set("mode", "prod") // one writer, exclusive
	}()
	wg.Wait()

	v, _ := cfg.Get("mode")
	fmt.Println("mode:", v)
}

RWMutex, okumalar baskın olduğunda ve her okuma kilit altında gerçek iş yaptığında karşılığını verir. Tek bir map araması gibi çok küçük kritik bölümler için düz bir Mutex çoğu zaman aynı hızdadır, çünkü okuma kilidinin kendi muhasebesi vardır. Seçmeden önce benchmark yapın.

Bir okuma kilidini yazma kilidine yükseltemezsiniz. Aynı goroutine'de RLock tutarken Lock çağırmak deadlock'a girer. Önce okuma kilidini bırakın, sonra yazma kilidini alın ve koşulu yeniden kontrol edin, çünkü arada başka bir yazar veriyi değiştirmiş olabilir.

Tek değerler için sync/atomic

Tek bir sayaç ya da bayrak için sync/atomic bir mutex'ten daha basit ve ucuzdur. Kullanılacak olanlar tipli sarmalayıcılardır (Go 1.19):

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

func main() {
	var requests atomic.Int64
	var ready atomic.Bool

	var wg sync.WaitGroup
	for range 1000 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			requests.Add(1)
		}()
	}
	wg.Wait()
	ready.Store(true)

	fmt.Println("requests:", requests.Load())
	fmt.Println("ready:", ready.Load())

	// CompareAndSwap: set only if the current value is what you expect.
	fmt.Println("swapped:", requests.CompareAndSwap(1000, 0), "now:", requests.Load())
}

Atomik işlemler aynı anda tek bir değeri korur. İki değer birlikte değişmek zorunda kaldığı anda (bir bakiye ve bir işlem sayısı, bir map ve boyutu) bir mutex kullanın. İki ayrı atomik işlemin arasına başka goroutine'ler girebilir.

sync.Once

sync.Once, aynı anda kaç goroutine çağırırsa çağırsın bir fonksiyonu tam olarak bir kez çalıştırır. Do'yu çağıran herkes ilk çağrı bitene kadar bekler. Bir şeyi tembel olarak başlatmanın standart yoludur:

package main

import (
	"fmt"
	"sync"
)

var (
	once   sync.Once
	config map[string]string
)

func loadConfig() map[string]string {
	once.Do(func() {
		fmt.Println("loading config (runs once)")
		config = map[string]string{"env": "prod"}
	})
	return config
}

// Go 1.21: OnceValue wraps a function and caches its result.
var port = sync.OnceValue(func() int {
	fmt.Println("computing port (runs once)")
	return 8080
})

func main() {
	var wg sync.WaitGroup
	for range 5 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			_ = loadConfig()
			_ = port()
		}()
	}
	wg.Wait()
	fmt.Println(loadConfig()["env"], port())
}

Her "runs once" satırı tam olarak bir kez görünür. Do'ya aktarılan fonksiyon panic olursa Once onu yine de tamamlanmış sayar ve asla yeniden denemez. sync.OnceValues aynısını iki değer döndüren fonksiyonlar için yapar; genellikle bir değer ve bir hata.

Mutex, channel ya da sync.Map

Durum	Kullanın
Birkaç goroutine'in yerinde güncellediği bir struct ya da map	struct içinde `sync.Mutex`
Çoğunlukla okuma, ara sıra yazma, okumalar gerçek iş yapıyor	`sync.RWMutex`
Tek bir sayaç ya da bayrak	`sync/atomic`
Tek seferlik başlatma	`sync.Once`, `sync.OnceValue`
Veriyi bir goroutine'den diğerine teslim etmek	bir channel
Anahtarları bir kez yazılıp çok kez okunan bir önbellek ya da ayrık anahtarlara dokunan goroutine'ler	`sync.Map`

sync.Map, kilitli bir map'in genel bir yerine geçmez. Tip parametreleri yoktur, bu yüzden değerler any olarak geri gelir ve yalnızca tablodaki iki durumda daha hızlıdır. Bir mutex ve normal bir map ile başlayın.

Sık yapılan hatalar

Bir mutex'i kopyalamak. sync.Mutex içeren bir struct'ı değerle aktarmak ya da bir değer alıcı kullanmak kilidi kopyalar. go vet, passes lock by value ya da copies lock value raporlar.
Tek bir goroutine'de iki kez kilitlemek. Go mutex'leri yeniden girilebilir değildir. Inc, Get'i çağırıyorsa ve ikisi de kilidi alıyorsa Inc sonsuza kadar bloklanır. Genel metotlar kilitlesin, özel yardımcılar kilidin tutulduğunu varsaysın.
Erken bir dönüşte kilidi açmayı unutmak. Bir nedeniniz yoksa defer kullanın.
Farklı sıralarda kilitlemek. Bir goroutine önce A'yı sonra B'yi, bir başkası önce B'yi sonra A'yı kilitlerse ikisi sonsuza kadar birbirini bekleyebilir. Birden fazla kilidi her zaman aynı sırayla alın.
Korunan veriyi dışa açmak. İç map'i bir metottan döndürmek, çağıranların onu kilit olmadan okuyup yazmasına izin verir. Bir kopya (maps.Clone, Go 1.21) ya da tek bir değer döndürün.
Yalnızca yazmaları korumak. Kilitli yazmalarla eşzamanlı kilitsiz okumalar yine race'tir. Testlerinizi go test -race ile çalıştırın.

Sıkça Sorulan Sorular

Go'da mutex nedir?

Bir sync.Mutex, mu.Lock() ile mu.Unlock() arasındaki kodu aynı anda yalnızca bir goroutine'in çalıştırmasına izin veren bir kilittir. Onu bir map ya da bir struct gibi birkaç goroutine'in okuyup yazdığı veriyi korumak için kullanırsınız. Sıfır değeri kilitli olmayan, kullanıma hazır bir mutex'tir.

Mutex yerine ne zaman RWMutex kullanmalıyım?

Okumalar yazmalardan çok daha fazla olduğunda ve her okuma kilidi anlamlı bir süre tuttuğunda. RLock aynı anda istediğiniz sayıda okuyucuyu içeri alır, Lock ise özel erişim için bekler. Kısa kritik bölümler için düz bir Mutex çoğu zaman aynı hızda ya da daha hızlıdır, bu yüzden geçmeden önce ölçün.

Go map'i eşzamanlı kullanım için güvenli mi?

Hayır. Eşzamanlı okumalar sorun değildir, ama başka herhangi bir okuma ya da yazmayla eşzamanlı bir yazma bir data race'tir ve çalışma zamanı genellikle bunu tespit edip fatal error: concurrent map writes (ya da concurrent map read and map write) ile çöker. Map'i bir sync.Mutex ya da sync.RWMutex ile koruyun veya belirli kullanım durumları için sync.Map kullanın.

Go'da sync.Mutex yeniden girilebilir (reentrant) mi?

Hayır. Kilidi tutan bir goroutine Lock'u yeniden çağırırsa kendini bekleyerek sonsuza kadar bloklanır. Kodu, dışa açık metotların kilidi alıp kilidin zaten tutulduğunu varsayan dışa kapalı yardımcıları çağıracağı şekilde yapılandırın.

İlgili kavramlar