🧠 Day 1: Go Concurrency Foundations & Goroutines

এই প্রথম দিনে তুমি শিখবে GoLang কনকারেন্সির (Concurrency) আসল শক্তি — Goroutine। আমরা ধাপে ধাপে শিখব কীভাবে GoLang একসাথে অনেক কাজ পরিচালনা করে, কীভাবে Goroutine কাজ করে, আর কেন এগুলো এত দ্রুত ও লাইটওয়েট।

🎯 আজকের লক্ষ্য

1. Concurrency ও Parallelism এর মধ্যে পার্থক্য পুরোপুরি বোঝা
2. Goroutine এর ভিতরের মেকানিজম শেখা
3. Go Scheduler (M-P-G Model) এর কাজ বোঝা
4. কেন Goroutine “Lightweight Thread” বলা হয়
5. Stack Management, Preemption, Scheduling Cycle বোঝা
6. কেন main ফাংশন শেষ হলে Goroutine গুলোও বন্ধ হয়ে যায় — সেটা দেখা।
7. Runtime Behavior, Memory Cost, Performance Insight বোঝা

🧩 ১. Concurrency vs Parallelism — মূল ভিত্তি

🔹 Concurrency = Structure of doing multiple tasks 🔹 Parallelism = Execution of those tasks together

Go Concurrent design follow করে → তাই multi-core এ parallel run করতে ও সক্ষম।

Go মূলত Concurrent-first language, মানে এটি এমনভাবে ডিজাইন করা হয়েছে যাতে তুমি কাজগুলোকে সুন্দরভাবে ভাগ করতে পারো, পরে runtime চাইলে একে parallel করতে পারে।

🧩 ২. Goroutine — Go র Concurrency এর হৃদপিণ্ড

Goroutine হলো Go-এর concurrency-এর সবচেয়ে গুরুত্বপূর্ণ ইউনিট। এটি হলো একধরনের “লাইটওয়েট থ্রেড” যা Go runtime নিজে তৈরি, ম্যানেজ, এবং schedule করে।

তুমি যেভাবে নতুন Goroutine শুরু করতে পারো:

go myFunction()

এতে runtime একটি নতুন goroutine তৈরি করে, যার নিজস্ব:

• ছোট stack (~2 KB থেকে শুরু)
• scheduling data (কোথায় চলছে, ready/blocked ইত্যাদি)
• heap shared with others (সব goroutine একই heap use করে)

🧠 মনে রাখো:

• Go তে সবকিছু Goroutine — main() নিজেও একটি goroutine।
• Go runtime goroutine দের OS thread এর উপর ম্যানেজ করে।

একদম ঠিক বলেছো 👍 — M-P-G model প্রথমে একটু জটিল মনে হয়, কিন্তু সহজ উদাহরণ আর তুলনা দিলে বিষয়টা একদম পরিষ্কার হয়ে যায়। নিচে আমি তোমার অংশটা খুব সহজ ভাষায়, উদাহরণসহ লিখে দিলাম 👇

🧩 ৩️. Go Runtime Scheduler (M–P–G Model সহজভাবে)

• Go এর মধ্যে একটি নিজস্ব “mini manager” আছে, যাকে বলে Scheduler।
• এই scheduler ঠিক করে কোন goroutine কখন, কোন CPU core এ চলবে।

⚙️ তিনটি অংশ

🎬 সহজ উদাহরণ

ধরো তুমি একজন রেস্টুরেন্ট ম্যানেজার:

• 🍽️ Goroutine (G) = অনেকগুলো অর্ডার (প্রতিটি রান্না আলাদা কাজ)
• 👨‍🍳 Processor (P) = একজন শেফের সহকারী, যিনি অর্ডার সাজিয়ে দেন
• 🔧 Machine (M) = আসল শেফ, যিনি রান্না করেন (CPU thread)

তুমি (Scheduler) দেখছো যেন শেফ (M) অলস না থাকে — তাই তুমি P এর queue থেকে অর্ডার (G) নিয়ে তাকে দিচ্ছো।

যদি এক শেফের সব অর্ডার শেষ হয়ে যায়, সে অন্য শেফের সহকারীর কাছ থেকে অর্ডার “চুরি” করতে পারে (এটাই work stealing) 😄

🔄 কাজের ধাপ

1. প্রতিটি P এর একটি ছোট queue থাকে যেখানে goroutine গুলো অপেক্ষা করে।
2. কোনো M (thread) ফাঁকা থাকলে, P তাকে কাজ দেয়।
3. GOMAXPROCS নির্ধারণ করে কয়টা P (logical core) ব্যবহার হবে।
4. যদি কোনো goroutine ব্লক হয় (যেমন I/O), scheduler সাথে সাথে অন্যটা চালায়।

⚙️ M:N Scheduling মানে কী

Go runtime অনেকগুলো (N) goroutine কে কম সংখ্যক (M) OS thread-এর উপর চালায়।

🧠 মানে — হাজার হাজার goroutine চলবে, কিন্তু CPU thread লাগবে খুব কম!

🌀 Work Stealing (সহজভাবে)

যদি কোনো processor-এর queue ফাঁকা থাকে, সে অন্য processor-এর queue থেকে goroutine নিয়ে নেয়।

👉 এতে CPU কখনো ফাঁকা বসে থাকে না, সবসময় ব্যস্ত থাকে।

✅ সংক্ষিপ্ত সারাংশ

🧩 চোখে দেখা ছোট ডায়াগ্রাম

G1, G2, G3  →  [P1]  →  [M1]
G4, G5, G6  →  [P2]  →  [M2]

যদি P1 এর queue ফাঁকা হয়, সে P2 থেকে G চুরি করতে পারে 🌀

🧩 ৪. Lightweight Thread মানে কী?

Goroutine-কে বলা হয় “Lightweight Thread”, কারণ এটি সাধারণ OS thread-এর তুলনায় অনেক হালকা, দ্রুত, এবং কম মেমরি-ব্যয়ী। Go runtime নিজেই এগুলো তৈরি ও নিয়ন্ত্রণ করে, তাই OS kernel-কে ঘনঘন ডাকার দরকার হয় না।

💡 কেন Lightweight বলা হয়?

Goroutine হালকা হওয়ার প্রধান কারণগুলো:

• Dynamic Stack
• Context switch kernel-level নয় → তাই অনেক দ্রুত
• Long-running goroutine কে runtime জোর করে থামিয়ে অন্য goroutine কে চালাতে পারে
• ফলে starvation বা hang হয় না

🧩 ৫️. Stack Growth Mechanism

• প্রতিটি Goroutine প্রায় ২KB stack দিয়ে শুরু হয়।
• যখন function call depth বাড়ে → Go runtime স্বয়ংক্রিয়ভাবে stack বড় করে ফেলে
• আর কাজ শেষ হলে আবার ছোট করে ফেলে।
• stack growth এবং shrink দুটোই safe ও automatic

➡️ ফল: তুমি লাখ go routine তৈরি করলেও out of memory হবে না।

🧩 ৬️. কেন Goroutine এত সস্তা (Cheap)

✅ ছোট Stack → Memory কম লাগে ✅ User-space Scheduler → Kernel-এ বারবার যেতে হয় না ✅ Auto Load Balancing → Scheduler নিজেই CPU গুলোতে কাজ ভাগ করে দেয় ✅ Communication Mechanism (Channels) → Safe data sharing

👉 ফলাফল: তুমি চাইলে ১ লাখ+ Goroutine তৈরি করতে পারবে এবং তাও প্রোগ্রাম ঠিকঠাক চলবে।

🧩 ৭️. Goroutine Lifecycle

New → Runnable → Running → Waiting → Runnable → Dead

• New: just created, not yet scheduled
• Runnable: ready queue তে অপেক্ষা করে
• Running: currently executing
• Waiting: I/O বা channel এর জন্য ব্লকড
• Dead: execution শেষ

Go runtime এ প্রতি P এর queue থাকে যেখানে Runnable goroutine থাকে।

🧩 ৮️. main() শেষ হলে কী হয়

• Go তে main() নিজেই একটি Goroutine (main Goroutine)।
• main() শেষ হলে program terminate হয়ে যায়, অন্য goroutine kill হয়ে যায়।

💻 Hands-On Exercises

1️⃣ Simple Goroutine

package main
import (
	"fmt"
	"time"
)
func main() {
	go func() {
		fmt.Println("Hello Goroutine!")
	}()
	time.Sleep(50 * time.Millisecond)
	fmt.Println("Main done")
}

🧩 Try removing time.Sleep() — you’ll likely not see “Hello, Goroutine!” because the main Goroutine ends first.

2️⃣ Multiple Goroutines

package main
import (
	"fmt"
	"time"
)
func printMsg(msg string) {
	fmt.Println(msg)
}
func main() {
	go printMsg("Alpha")
	go printMsg("Beta")
	go printMsg("Gamma")
	time.Sleep(100 * time.Millisecond)
	fmt.Println("Main exiting")
}

Run it several times — you’ll see the output order change. That’s because Goroutines run concurrently; the scheduler decides their order.

3️⃣ Demonstrate Main Exit

func main() {
	go fmt.Println("A")
	go fmt.Println("B")
	go fmt.Println("C")
}

Output: → often nothing prints, because main exits immediately.

🧠 নিজে ভাবো

1. Concurrency vs Parallelism এর মূল পার্থক্য কি?
2. কেন Goroutine lightweight?
3. M-P-G মডেল এর ভূমিকা কি?
4. Stack growth কেন important?
5. main() শেষ হলে program কেন terminate হয়?
6. Preemption কীভাবে scheduler কে সহায়তা করে?

🧾 সারসংক্ষেপ

📚 রিসোর্স

• 📘 Go by Example — Goroutines 
• 📘 Go Tour — Concurrency Section 
• 📖 Go Blog — Concurrency is Not Parallelism (Rob Pike) 
• 📖 Inside the Go Scheduler (Morsmachine) 
• 🎥 Rob Pike — “Concurrency Is Not Parallelism” 
• 🎥 GopherCon — “Inside the Go Scheduler” by Dmitry Vyukov 

🧩 Mini Challenge

একটা প্রোগ্রাম লিখো যেটা:

• ১০০ টা goroutine চালাবে
• প্রত্যেকে নিজের নাম প্রিন্ট করবে (“Worker 1” থেকে “Worker 100”)
• main ফাংশনে একটা sleep দাও যাতে সবগুলো চালাতে পারে
• output order observe করো (প্রতিবার ভিন্ন হবে)

🧠 Deep Think Exercise

🔮 Day 2 Preview: Channels

পরের দিন আমরা শিখব Go এর সবচেয়ে ম্যাজিকাল অংশ — Channel — Goroutine দের মধ্যে নিরাপদ communication এর উপায়। আমরা দেখব:

• Unbuffered vs Buffered Channel
• Data Synchronization
• Channel blocking behavior
• Deadlock avoidance pattern