Day 4: Select Statement & Multiplexing

select-কে আপনি goroutine-দের “ট্রাফিক কন্ট্রোলার” বলতে পারেন। এটি একটি goroutine-কে একাধিক চ্যানেলের উপর একবারে নজর রাখতে সাহায্য করে এবং যেটি আগে প্রস্তুত (ready) হয়, সেটির উপর ভিত্তি করে কাজ করে।

🧠 কনসেপ্ট বোঝা

🤔 select কেন প্রয়োজন?

ধরুন, আপনার দুটি চ্যানেল আছে, ch1 এবং ch2। আপনি দুটো থেকেই ডেটা আশা করছেন। আপনি যদি এভাবে লেখেন:

data1 := <-ch1 // এখানে আটকে গেল
data2 := <-ch2 // এটি আর চলবে না, যদি ch1 এ ডেটা না আসে

যদি ch1-এ কোনো ডেটা না আসে, কিন্তু ch2-তে ডেটা চলে আসে, তবুও আপনার প্রোগ্রাম 🔥ch1-এর জন্য অনন্তকাল অপেক্ষা (block) করতে থাকবে।🔥

select এই সমস্যার সমাধান করে। এটি সব চ্যানেলের দিকে “তাকিয়ে” থাকে এবং যে চ্যানেলটি প্রথম ডেটা পাঠাতে বা গ্রহণ করতে প্রস্তুত হয়, সেটির কোড ব্লকটি চালায়।

🔹 1. select কী করে এবং select সিনট্যাক্স

select অনেকটা switch এর মতো, কিন্তু এটি কাজ করে চ্যানেল অপারেশন (send/receive) এর উপর।

👉 কাজ: একাধিক চ্যানেলের মধ্যে যে চ্যানেল আগে ready হয়, সেটার case execute হয়।

📜 select সিনট্যাক্স এবং “First Ready Wins”

select-এর সিনট্যাক্স switch-এর মতোই।

select {
case data := <-ch1:
    // ch1 থেকে ডেটা রিসিভ হলে এটি চলবে
    fmt.Println("ch1 থেকে পেলাম:", data)
case ch2 <- "Hi":
    // ch2-তে ডেটা সেন্ড করা সম্ভব হলে এটি চলবে
    fmt.Println("ch2-তে 'Hi' পাঠালাম")
case <-ch3:
    // ch3 থেকে ডেটা রিসিভ হলে (কিন্তু ডেটা ব্যবহার না করলে)
    fmt.Println("ch3 থেকে সিগন্যাল পেলাম")
}

🚦 চিত্র: select যেভাবে কাজ করে

select স্টেটমেন্টকে একটি ফানেল হিসেবে ভাবুন:

           [goroutine]
               |
          <--select-->
         /      |     \
        /       |      \
   (অপেক্ষা) (প্রস্তুত) (অপেক্ষা)
      |         |        |
    [ch1]     [ch2]    [ch3]

• select তিনটি চ্যানেলের দিকেই নজর রাখে।
• ধরুন, ch2 প্রথমে ডেটা রিসিভ করার জন্য প্রস্তুত হলো।
• select অবিলম্বে ch2-এর case ব্লকটি নির্বাচন করবে এবং চালাবে। অন্য case-গুলো উপেক্ষা করা হবে।
• “First Ready Wins”: এটিই মূল নিয়ম। যে প্রথম প্রস্তুত হবে, সেই জিতবে।
• যদি একাধিক case একই সাথে প্রস্তুত থাকে (খুব বিরল, তবে সম্ভব), select তখন তাদের মধ্যে থেকে এলোমেলোভাবে (randomly) একটিকে বেছে নেয়। এটি কোনো একটি চ্যানেলের প্রতি পক্ষপাত (bias) দূর করতে সাহায্য করে।

🔹 2. select এর রুল: “First Ready Wins”

• একাধিক চ্যানেল ready থাকলে → Go র‍্যান্ডমলি একটি বেছে নেয়।
• কোনো চ্যানেল ready না থাকলে → ব্লক করে (অপেক্ষা করে)।
• যদি default থাকে → ব্লক করে না।
• একবারে শুধু একটাই case চলে।

🔹 3. 💨 নন-ব্লকিং অপারেশন: default

যদি আপনি চান যে select কোনো চ্যানেলের জন্য একটুও অপেক্ষা না করুক, তবে default কেস ব্যবহার করতে পারেন।

🧩 default কেস তখনই চলে যখন অন্য কোনো case তাৎক্ষণিকভাবে প্রস্তুত থাকে না।

select {
case data := <-ch:
    fmt.Println("ডেটা রিসিভড:", data)
default:
    // কোনো চ্যানেল রেডি না থাকলে এটি সাথে সাথে চলবে
    fmt.Println("এখনো কোনো ডেটা নেই, আমি অন্য কাজ করছি...")
}

এটি “try-receive” বা “non-blocking receive” করার একটি সহজ উপায়।

🔹 4. ⏳ time.After দিয়ে টাইমআউট (Timeout)

অনেক সময় আমরা অনন্তকাল অপেক্ষা করতে চাই না। আমরা একটি নির্দিষ্ট সময় পর্যন্ত অপেক্ষা করতে পারি। time.After(duration) একটি চ্যানেল রিটার্ন করে, যা নির্দিষ্ট সময় (duration) পার হওয়ার পর একটি সিগন্যাল পাঠায়।

এটি select-এর সাথে টাইমআউট তৈরির জন্য দুর্দান্ত:

select {
case data := <-longRunningTaskCh:
    fmt.Println("কাজ সম্পন্ন:", data)
case <-time.After(2 * time.Second):
    // 2 সেকেন্ড পার হয়ে গেলে এটি চলবে
    fmt.Println("টাইমআউট! আর অপেক্ষা করা সম্ভব না।")
}

এটি একটি ক্লাসিক প্যাটার্ন: হয় কাজটি সম্পন্ন হবে, অথবা টাইমআউট হবে—দুটির মধ্যে 🔥যেটি আগে ঘটবে।🔥

🔀 প্যাটার্ন: ফ্যান-ইন (Fan-In) / মাল্টিপ্লেক্সিং

ফ্যান-ইন হলো এমন একটি প্যাটার্ন যেখানে আপনি একাধিক ইনপুট চ্যানেল থেকে ডেটা নিয়ে একটিমাত্র আউটপুট চ্যানেলে একত্রিত করেন। এটি select-এর একটি খুব সাধারণ ব্যবহার।

ধরুন, আপনার দুটি সোর্স (producer) আছে, যারা প্রত্যেকে নিজেদের চ্যানেলে ডেটা পাঠাচ্ছে। আপনি সেই দুটি চ্যানেলকে “merge” করে একটি চ্যানেলে আনতে চান।

আমরা এই কাজটি করার জন্য একটি ফাংশন তৈরি করতে পারি।

💻 Exercises

⚡ Example 1: Two Channels, First Ready Wins

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)
 
    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "🍎 From channel 1"
    }()
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "🍌 From channel 2"
    }()
 
    select {
    case msg1 := <-ch1:
        fmt.Println(msg1)
    case msg2 := <-ch2:
        fmt.Println(msg2)
    }
}

// select নিজেই ব্লক করবে
select {
case msg := <-ch:
    fmt.Println(msg)
}
 
// WaitGroup দরকার যখন কোনো channel নেই
var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    fmt.Println("working...")
}()
wg.Wait()

ch1 := make(chan string)
ch2 := make(chan string)
 
select {
case msg1 := <-ch1:
    fmt.Println(msg1)
case msg2 := <-ch2:
    fmt.Println(msg2)
}

fatal error: all goroutines are asleep - deadlock!

go func() { ch1 <- "🍎 From channel 1" }()
go func() { ch2 <- "🍌 From channel 2" }()

ch1 := make(chan string, 1)
ch1 <- "🍎 From buffered channel"
select {
case msg := <-ch1:
    fmt.Println(msg)
}

⚙️ Example 2: Add Default Case (Non-blocking)

select {
case msg := <-ch1:
    fmt.Println("Received:", msg)
default:
    fmt.Println("No channel ready — moving on 🚀")
}

⏰ Example 3: Add Timeout

select {
case msg := <-ch1:
    fmt.Println("Got:", msg)
case <-time.After(2 * time.Second):
    fmt.Println("Timeout! ⏰ No data received.")
}

🧩 Bonus: Context Cancellation

যদি নির্দিষ্ট সময় পরে সব বন্ধ করতে চাও 👇

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
 
for {
    select {
    case msg := <-out:
        fmt.Println(msg)
    case <-ctx.Done():
        fmt.Println("🛑 Stopped by context timeout.")
        return
    }
}

🧾 Mini Cheat Sheet — select Quick Recall

🧠 Summary (বাংলায় সারাংশ)

• select একাধিক চ্যানেল একসাথে মনিটর করে।
• যে চ্যানেল আগে ready হয়, সেটার case চালু হয়।
• default case দিলে ব্লক হয় না।
• time.After দিয়ে timeout সেট করা যায়।
• Fan-in pattern দিয়ে একাধিক channel merge করা যায়।
• context.WithTimeout দিয়ে clean stop করা যায়।