حزمة sync

حزمة sync — Sync Package

القنوات هي الطريقة المفضلة للتزامن في Go، لكن أحياناً تحتاج أدوات منخفضة المستوى. حزمة sync توفر أقفال (mutexes) ومجموعات انتظار وغيرها.

سباق البيانات — Race Condition

قبل أن نتعلم الحلول، لنفهم المشكلة:

main.go

package main

import (
    "fmt"
    "sync"
)

func main() {
    // ❌ بدون حماية — سباق بيانات!
    // Without protection — data race!
    counter := 0
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter++ // عدة goroutines تُعدّل نفس المتغير!
        }()
    }

    wg.Wait()
    fmt.Println("العدّاد (قد يكون خاطئاً):", counter)
    fmt.Println("المتوقع: 1000")
    fmt.Println("💡 في بيئة حقيقية، استخدم: go run -race main.go")
}

Output:

ملاحظة: في Go Playground قد تحصل على 1000 أحياناً لأن الجدولة تختلف. لكن على جهازك مع -race flag ستكتشف المشكلة.

sync.Mutex — القفل المتبادل

Mutex يضمن أن goroutine واحد فقط يصل للمنطقة الحرجة:

main.go

package main

import (
    "fmt"
    "sync"
)

// عدّاد آمن — Thread-safe counter
type SafeCounter struct {
    mu    sync.Mutex
    value int
}

// زيادة — Increment (thread-safe)
func (c *SafeCounter) Increment() {
    c.mu.Lock()         // اقفل — Lock
    defer c.mu.Unlock() // افتح عند الخروج — Unlock on exit
    c.value++
}

// القراءة — Read (also needs lock)
func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

func main() {
    counter := &SafeCounter{}
    var wg sync.WaitGroup

    // 1000 goroutine تزيد العدّاد — 1000 goroutines increment
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment()
        }()
    }

    wg.Wait()
    fmt.Println("العدّاد:", counter.Value()) // دائماً 1000 ✅
}

Output:

sync.RWMutex — قفل القراءة/الكتابة

إذا كانت القراءات أكثر بكثير من الكتابات، RWMutex أفضل — يسمح بقراءات متزامنة:

main.go

package main

import (
    "fmt"
    "sync"
)

// ذاكرة مؤقتة آمنة — Thread-safe cache
type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}

func NewCache() *Cache {
    return &Cache{data: make(map[string]string)}
}

// كتابة — تحتاج قفل كامل — Write needs full lock
func (c *Cache) Set(key, value string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = value
}

// قراءة — تحتاج قفل قراءة فقط — Read needs read lock only
func (c *Cache) Get(key string) (string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    val, ok := c.data[key]
    return val, ok
}

func main() {
    cache := NewCache()
    var wg sync.WaitGroup

    // كتّاب — Writers
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key_%d", id)
            cache.Set(key, fmt.Sprintf("قيمة_%d", id))
        }(i)
    }

    wg.Wait()

    // قرّاء — Readers
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key_%d", id)
            if val, ok := cache.Get(key); ok {
                fmt.Printf("%s = %s\n", key, val)
            }
        }(i)
    }

    wg.Wait()
}

Output:

sync.WaitGroup — مجموعة الانتظار

أفضل طريقة لانتظار مجموعة goroutines:

main.go

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup

    tasks := []string{"تنزيل", "معالجة", "حفظ", "إرسال إشعار"}

    for _, task := range tasks {
        wg.Add(1) // أضف 1 قبل بدء goroutine — Add 1 before starting
        go func(t string) {
            defer wg.Done() // اطرح 1 عند الانتهاء — Subtract 1 when done
            fmt.Printf("⏳ بدء: %s\n", t)
            time.Sleep(100 * time.Millisecond)
            fmt.Printf("✅ انتهى: %s\n", t)
        }(task)
    }

    wg.Wait() // انتظر حتى يصبح العدّاد 0 — Wait until counter is 0
    fmt.Println("\n🎉 كل المهام اكتملت!")
}

Output:

قواعد WaitGroup:

Add(n) — قبل بدء goroutine
Done() — عند انتهاء goroutine (يساوي Add(-1))
Wait() — يُعيق حتى العدّاد = 0

sync.Once — تنفيذ مرة واحدة فقط

مفيد للتهيئة التي يجب أن تحدث مرة واحدة فقط:

main.go

package main

import (
    "fmt"
    "sync"
)

// اتصال قاعدة بيانات (محاكاة) — DB connection (simulated)
type DB struct {
    Name string
}

var (
    dbInstance *DB
    dbOnce     sync.Once
)

// تهيئة قاعدة البيانات — مرة واحدة فقط!
// Initialize DB — once only!
func GetDB() *DB {
    dbOnce.Do(func() {
        fmt.Println("🔌 إنشاء اتصال قاعدة البيانات (مرة واحدة فقط)")
        dbInstance = &DB{Name: "production_db"}
    })
    return dbInstance
}

func main() {
    var wg sync.WaitGroup

    // 5 goroutines تطلب الاتصال — 5 goroutines request connection
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            db := GetDB()
            fmt.Printf("goroutine %d: يستخدم %s\n", id, db.Name)
        }(i)
    }

    wg.Wait()
}

Output:

نمط عملي: تجمّع العمال — Worker Pool

main.go

package main

import (
    "fmt"
    "sync"
    "time"
)

// مهمة — Job
type Job struct {
    ID    int
    Input int
}

// نتيجة — Result
type Result struct {
    JobID  int
    Output int
}

// عامل — Worker
func worker(id int, jobs <-chan Job, results chan<- Result, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        fmt.Printf("عامل %d: يعالج مهمة %d\n", id, job.ID)
        time.Sleep(50 * time.Millisecond) // محاكاة عمل — Simulate work
        results <- Result{JobID: job.ID, Output: job.Input * job.Input}
    }
}

func main() {
    const numWorkers = 3
    const numJobs = 9

    jobs := make(chan Job, numJobs)
    results := make(chan Result, numJobs)

    // بدء العمال — Start workers
    var wg sync.WaitGroup
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    // إرسال المهام — Send jobs
    for j := 1; j <= numJobs; j++ {
        jobs <- Job{ID: j, Input: j}
    }
    close(jobs)

    // انتظار الاكتمال وإغلاق النتائج — Wait and close results
    go func() {
        wg.Wait()
        close(results)
    }()

    // جمع النتائج — Collect results
    fmt.Println("\nالنتائج:")
    for r := range results {
        fmt.Printf("  مهمة %d → %d\n", r.JobID, r.Output)
    }
}

Output:

كشف سباق البيانات — Race Detector

Go تأتي مع كاشف سباق بيانات مدمج:

# تشغيل مع كشف السباق — Run with race detection
go run -race main.go
go test -race ./...

# يكتشف الأخطاء مثل:
# WARNING: DATA RACE
# Write at 0x00c0000b4010 by goroutine 7:
# Previous read at 0x00c0000b4010 by goroutine 6:

استخدمه دائماً أثناء التطوير والاختبار!

متى تستخدم القنوات vs Mutex؟

استخدم القنوات عندما	استخدم Mutex عندما
تمرير ملكية البيانات	حماية حالة مشتركة
توزيع مهام	عدّاد أو cache
التواصل بين goroutines	قراءة/كتابة بسيطة

تحدي — Challenge

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex
    var wg sync.WaitGroup
    counter := 0

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := 0; j < 100; j++ {
                // استخدم mu.Lock/Unlock لزيادة counter بأمان
                // اكتب الكود هنا
            }
        }()
    }

    wg.Wait()
    fmt.Printf("النتيجة النهائية: %d\n", counter)
}