🧠 Go Concurrency Day 3 — WaitGroups & Mutex (Synchronization)

🎯 লক্ষ্য

আজ তুমি শিখবে কীভাবে একাধিক goroutine একসাথে চললেও প্রোগ্রাম safe এবং predictable রাখা যায়। মূলত আমরা শিখবো:

• WaitGroup
• Mutex / RWMutex
• Race Condition
• Race Detector (go run -race)
• Channels বনাম Mutex ব্যবহার কবে উপযুক্ত

কেন synchronization দরকার?

Go-তে goroutine গুলো একই সাথে চলতে পারে।

কিন্তু যদি তারা shared data ব্যবহার করে, তখন ভুল মান, অসামঞ্জস্যপূর্ণ অবস্থা, অথবা race condition ঘটতে পারে।

1) WaitGroup কী?

sync.WaitGroup ব্যবহার করা হয় একাধিক goroutine শেষ হওয়া পর্যন্ত main function কে অপেক্ষা করানোর জন্য।

WaitGroup দিয়ে আমরা বলতে পারি:

“এই X সংখ্যক goroutine শেষ না হওয়া পর্যন্ত main() বন্ধ হবে না।”

🔹 মূল তিনটি মেথড

🔸 উদাহরণ: ৫টি goroutine চালিয়ে WaitGroup দিয়ে অপেক্ষা

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var wg sync.WaitGroup
 
    wg.Add(5) // ৫টা goroutine হবে
 
    for i := 1; i <= 5; i++ {
        go func(id int) {
            defer wg.Done()
            fmt.Println("Goroutine চলছে:", id)
        }(i)
    }
 
    wg.Wait() // সব goroutine শেষ না হওয়া পর্যন্ত অপেক্ষা
    fmt.Println("সব goroutine শেষ হয়েছে ✅")
}

🧩 কী হলো এখানে: WaitGroup main function কে ব্লক করে রাখছে যতক্ষণ না সব goroutine শেষ হয়।

2) Shared Data + Mutex

Mutex-এর পূর্ণরূপ হলো “Mutual Exclusion” (পারস্পরিক বর্জন)।

এর মূল ধারণা হলো: একই সময়ে শুধুমাত্র একটি goroutine-কে একটি নির্দিষ্ট ডেটা (shared data) অ্যাক্সেস বা পরিবর্তন করার অনুমতি দেওয়া।

⚠️ সমস্যা: Data Race

যখন একাধিক goroutine 🔥একই data🔥 একযোগে পরিবর্তন করার চেষ্টা করে, তখন data race নামক একটি মারাত্মক বাগ তৈরি হয়। এর ফলে ডেটা নষ্ট (corrupt) হয়ে যেতে পারে বা অ্যাপ্লিকেশনটি ক্র্যাশ করতে পারে।

🔒 সমাধান: sync.Mutex

Go-তে এই data race ঠেকানোর জন্য sync প্যাকেজের Mutex ব্যবহার করা হয়। এটি একটি তালার (lock) মতো কাজ করে।

এর দুটি প্রধান মেথড রয়েছে:

• Lock(): ডেটা অ্যাক্সেস করার আগে এই মেথড কল করা হয়।

  • যদি তালাটি খোলা থাকে, তবে goroutine-টি এটি লক করে এবং কাজ শুরু করে।
  • যদি অন্য goroutine আগেই লক করে রাখে, তবে এটি তালা খোলার জন্য অপেক্ষা (block) করে।

• Unlock(): ডেটা পরিবর্তন করা শেষ হলে এই মেথড কল করা হয়।

  • এটি তালাটি খুলে দেয়, যাতে অপেক্ষারত অন্য goroutine-গুলি ডেটা অ্যাক্সেস করতে পারে।

🔸 উদাহরণ: 1000 বার Counter বৃদ্ধি (Safe)

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var counter = 0
    var mu sync.Mutex
    var wg sync.WaitGroup
 
    wg.Add(1000)
 
    for i := 0; i < 1000; i++ {
        go func() {
            defer wg.Done()
            mu.Lock()
            counter++ // এখন নিরাপদ
            mu.Unlock()
        }()
    }
 
    wg.Wait()
    fmt.Println("Final Counter:", counter)
}

🔒 এখানে Mutex counter-কে একসাথে এক goroutine দ্বারা পরিবর্তন নিশ্চিত করছে।

3) Mutex বাদ দিলে কী হয়? (Race Condition!)

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var counter = 0
    var wg sync.WaitGroup
 
    wg.Add(1000)
 
    for i := 0; i < 1000; i++ {
        go func() {
            defer wg.Done()
            counter++ // ❌ বিপদ! একাধিক goroutine একসাথে লিখছে
        }()
    }
 
    wg.Wait()
    fmt.Println("Final Counter:", counter)
}

💥 Output পরিবর্তনশীল হবে — কখনও 800, কখনও 950, কখনও 1000 না। এটাই Race Condition।

4) Race Detector ব্যবহার

Go-তে বিল্ট-ইন race detector আছে।

go run -race main.go

এটি বলবে:

WARNING: DATA RACE
Read at ...
Previous write at ...

এর মানে তোমার কোডে একাধিক goroutine একসাথে data অ্যাক্সেস করছে।

var (
	value int
	mu    sync.RWMutex
)
 
func reader(id int, wg *sync.WaitGroup) {
	defer wg.Done()
	mu.RLock()
	fmt.Println("Reader", id, "read:", value)
	mu.RUnlock()
}
 
func writer(wg *sync.WaitGroup) {
	defer wg.Done()
	mu.Lock()
	value++
	fmt.Println("Writer updated value:", value)
	mu.Unlock()
}

🔍 Channels বনাম Mutex

🧩 অনুশীলন

🧭 সারসংক্ষেপ