Mutex في Golang: sync.Mutex وRWMutex وatomic وsync.Once

حماية البيانات المشتركة

يسمح sync.Mutex لـ goroutine واحدة في كل مرة بدخول الشيفرة بين Lock وUnlock. ضع الـ mutex بجوار البيانات التي يحرسها، عادة في البنية نفسها:

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"))
}

يطبع هذا دائمًا hits: 10000. دون القفل، ستُسقط 100 goroutine تكتب في الخريطة نفسها البرنامج عادة برسالة fatal error: concurrent map writes. هذا الخطأ يأتي من فحص في وقت التشغيل لا يضمن الاكتشاف دائمًا، ولا يمكن التعافي منه، وغياب الانهيار لا يثبت صحة الشيفرة.

تفاصيل مهمّة:

• القيمة الصفرية لـ sync.Mutex غير مقفلة وجاهزة. لا حاجة لدالة بناء.
• تستخدم التوابع مستقبِل مؤشر (*Counter). مستقبِل القيمة سيقفل نسخة من الـ mutex، وهذا لا يحمي شيئًا.
• defer c.mu.Unlock() مباشرة بعد Lock تعني أن كل مسار عودة، وكل panic، يحرّر القفل.
• كل وصول يمرّ عبر القفل، بما في ذلك القراءات. القراءة دون قفل بينما تكتب goroutine أخرى ما زالت سباق بيانات.

أبقِ القسم الحرج صغيرًا

تفكّ defer القفل في نهاية الدالة. هذا صحيح للتوابع القصيرة مثل السابقة. أما في دالة أطول ففكّ القفل حالما تنتهي من لمس البيانات المشتركة، حتى لا تنتظر الـ goroutines الأخرى عملًا لا يحتاج القفل:

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
}

الاحتفاظ بقفل عبر استدعاءات شبكية أو إدخال وإخراج على القرص أو إرسال على قناة هو أشيع سبب لبطء البرامج المتزامنة، والإرسال على قناة تحت قفل سبب شائع للجمود.

RWMutex للبيانات كثيرة القراءة

لـ sync.RWMutex وضعان. يأخذ RLock/RUnlock قفل قراءة مشتركًا يمكن لكثير من الـ goroutines حمله معًا. ويأخذ Lock/Unlock قفل الكتابة الحصري، الذي ينتظر حتى يغادر كل القرّاء.

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 ثماره عندما تهيمن القراءات وتؤدّي كل قراءة عملًا حقيقيًا تحت القفل. للأقسام الحرجة الصغيرة جدًا مثل بحث واحد في خريطة، يكون Mutex العادي غالبًا بالسرعة نفسها، لأن لقفل القراءة حساباته الخاصة. قِس الأداء قبل الاختيار.

لا يمكنك ترقية قفل قراءة إلى قفل كتابة. استدعاء Lock مع الاحتفاظ بـ RLock في الـ goroutine نفسها يسبّب جمودًا. حرّر قفل القراءة أولًا، ثم خذ قفل الكتابة وافحص الشرط مجددًا، لأن كاتبًا آخر قد يكون غيّر البيانات في الأثناء.

sync/atomic للقيم المفردة

لعدّاد أو علم واحد، sync/atomic أبسط وأرخص من mutex. الأغلفة ذات الأنواع (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())
}

تحمي العمليات الذرّية قيمة واحدة في كل مرة. حالما يجب أن تتغيّر قيمتان معًا (رصيد وعدد معاملات، أو خريطة وحجمها)، استخدم mutex. عمليتان ذرّيتان منفصلتان قد تتداخل بينهما goroutines أخرى.

sync.Once

تنفّذ sync.Once دالة مرة واحدة بالضبط، مهما كان عدد الـ goroutines التي تستدعيها في الوقت نفسه. كل من يستدعي Do ينتظر حتى ينتهي الاستدعاء الأول. وهي الطريقة المعتادة للتهيئة الكسولة:

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())
}

كل سطر "runs once" يظهر مرة واحدة بالضبط. إذا سبّبت الدالة الممرّرة إلى Do حالة panic، تعدّها Once منتهية ولا تعيد المحاولة أبدًا. وتفعل sync.OnceValues الشيء نفسه للدوال التي تعيد قيمتين، عادة قيمة وخطأ.

Mutex أم قناة أم sync.Map

ليست sync.Map بديلًا عامًا لخريطة مقفلة. لا معاملات نوع لها، فتعود القيم كـ any، وهي أسرع فقط في الحالتين المذكورتين في الجدول. ابدأ بـ mutex وخريطة عادية.

أخطاء شائعة

• نسخ mutex. تمرير بنية تحتوي sync.Mutex بالقيمة، أو استخدام مستقبِل قيمة، ينسخ القفل. يبلغ go vet عن passes lock by value أو copies lock value.
• القفل مرتين في goroutine واحدة. أقفال Go غير قابلة لإعادة الدخول. إذا استدعت Inc الدالة Get وأخذت كلتاهما القفل، تتوقّف Inc إلى الأبد. اجعل التوابع العامة تقفل، والدوال المساعدة الخاصة تفترض أن القفل مأخوذ.
• نسيان فكّ القفل عند عودة مبكرة. استخدم defer ما لم يكن لديك سبب لغير ذلك.
• القفل بترتيبات مختلفة. إذا أخذت goroutine القفل A ثم B بينما أخذت أخرى B ثم A، قد تنتظر كل منهما الأخرى إلى الأبد. احصل دائمًا على الأقفال المتعدّدة بالترتيب نفسه.
• كشف البيانات المحروسة. إعادة الخريطة الداخلية من تابع تتيح للمستدعين قراءتها والكتابة فيها دون القفل. أعد نسخة (maps.Clone، Go 1.21) أو قيمة واحدة.
• حماية الكتابات وحدها. القراءات غير المقفلة المتزامنة مع كتابات مقفلة ما زالت سباقات. شغّل اختباراتك بـ go test -race.