Goroutines
A Comprehensive Guide to Goroutines [Burmese]
Google က 2009 မှာ Go ကို develop လုပ်ခဲ့တယ်၊ Simplicity, performance နဲ့ concurrency တွေကိုအဓိကထားပြီး design လုပ်ခဲ့တယ်၊ Static typing, garbage collection နဲ့ သူ့ရဲ့ standard library တွေဟာ web server တွေကနေ distributed application တွေရေးဖို့ထိ အဆင်ပြေတဲ့အတွက် လူကြိုက်များတယ်။ Go မှာ စုစုပေါင်း reserved keywords 25 ခုပဲရှိတယ်။
Go concurrency model မှာ Goroutine ကအဓိကဖြစ်တယ် concurrent task တွေအတွက် Goroutine တွေသည် lightweight ဖြစ်တယ်၊ efficient ဖြစ်တယ်။ ဒီကနေ့ modern software တွေမှာ task တွေအများကြီးကို တပြိုင်တည်း handle လုပ်နိုင်ဖို့က အရေးကြီးတဲ့အချက်တွေမှာတစ်ခုအပါဝင်ဖြစ်တယ်၊ Concurrency အတွက် Goroutine တွေက low-level thread တွေကို abstract လုပ်ပြီး complexity အနည်းဆုံးနဲ့ developer-friendly ဖြစ်အောင် လုပ်ပေးထားတယ်။ realtime system တွေ microservice တွေ implement လုပ်ဖို့အတွက် အရမ်းအရေးပါတယ်။
Goroutine ဆိုတာဘာလဲ
Goroutines ဆိုတာ lightweight threads တွေဖြစ်တယ်၊ Go Runtime ကနေ manage လုပ်တယ်၊ OS ကနေမလုပ်ဘူး။ OS thread တွေနဲ့မတူဘူး။ Goroutine တွေက ဘာကြောင့် ပိုပြီး lightweight ဖြစ်လဲ efficient ဖြစ်လဲဆိုတော့ initial stack size 2-8KB ပဲရှိတယ် လိုအပ်သလောက်ထပ်တိုးသွားမယ်၊ OS thread တွေပေါ်မှာတပြိုင်နက်တည်း အလုပ်လုပ်တယ်လို့ပြောလို့ရမယ်၊ OS thread တွေဆိုရင် initial stack size က 1-8MB ရှိတယ်၊ Goroutine တွေက create လုပ်ရတာ destroy လုပ်ရတာ Context switching တွေမှာ ပိုမြန်တယ်၊ အဓိကက OS Thread တွေကို reuse ပြန်လုပ်တာမျိုးလုပ်တယ်၊ ဥပမာ Thread တစ်ခု create လုပ်ပြီးရင် destroy မလုပ်ဘဲ park လုပ်ထားပြီး လိုမှ ပြန်ထုတ်သုံးတာမျိုးလုပ်တယ်။ ဆိုလိုတာက Goroutine ဆိုတာလည်း OS Thread တွေကိုသုံးတာပဲ ဒါပေမယ့် efficient ဖြစ်အောင် သုံးတဲ့ mechanism တစ်ခုလို့ပြောလို့ရတယ်။
Goroutine တစ်ခုကို function ရှေ့မှာ go keyword သုံးပြီး launch လုပ်ပေးရတယ်။ caller function ဖြစ်တဲ့ main function နဲ့ concurrently run မယ် ဆိုလိုတာက main function သည် သူ့ကိုပြီးတဲ့ထိမစောင့်နေဘူး။
package main
import (
"fmt"
"time"
)
func sayHello(name string) {
fmt.Printf(" Hello , %s!\n", name)
}
func main() {
go sayHello("Alice") // Starts a Goroutine
fmt.Println("Main function")
time.Sleep(time.Second) // Wait to see output
}
ဒီနမူနာမှာ time.Sleep ဘာကြောင့်ထည့်လဲဆိုတော့ Goroutine မပြီးသေးဘဲ program exit ဖြစ်မသွားဖို့အတွက်ဖြစ်တယ်။
Under the Hood
Goroutine တွေ အလုပ်လုပ်ပုံကို အတွင်းကျကျနားလည်ထားရင် ပိုကောင်းတယ်။
Go runtime မှာ Goroutine တွေကို manage လုပ်ဖို့ Go Scheduler ပါတယ်။ Go scheduler သည် M:N scheduling model ကိုသုံးတယ်။ Goroutine (M) နဲ့ OS threads (N) ကို map လုပ်တာလို့နားလည်ထားလို့ရတယ်။ total Goroutine အရေအတွက်ကို GOMAXPROCS နဲ့ ထိန်းပေးလို့ရတယ်။ နောက်တစ်ခုသိထားဖို့လိုတာက preemtive scheduling ကိုသုံးတဲ့အကြောင်းပါ၊ preemtive scheduling ဆိုတာက Goroutine တစ်ခုတည်းကနေ thread တစ်ခုကို အပိုင်စီးထားတာမျိုးမဖြစ်အောင် interrupt လုပ်ပြီး တခြား Goroutine တွေကိုပါပေး run တာမျိုးကိုပြောတာပါ။
Communication between Goroutines
Goroutine တွေက channel တွေကိုသုံးပြီး communicate လုပ်တယ် channel တွေမှာ message passing လုပ်နိုင်တဲ့ mechanism တွေ ပါတယ်။ channel တွေနဲ့ဆို thread-safe communication ရမယ်၊ shared memory issue တွေ ရှောင်ပြီးသားဖြစ်သွားမယ်။
<-chan for receive-only
chan<- for send-only
package main
import (
"fmt"
"time"
)
func producer(ch chan<- int) {
ch <- 42 // Send
}
func main() {
ch := make(chan int) // Unbuffered channel
go producer(ch)
value := <-ch // Receive
fmt.Println(value) // Outputs: 42
time.Sleep(time.Second)
}
Buffered vs Unbuffered Channels
ဒီနေရာမှာ buffer နဲ့ unbuffer ဆိုတာ ဘာလဲသိဖို့လိုမယ်၊ I/O operations တွေမှာ buffer ဆိုတာက data ကို process မလုပ်ခင် store လုပ်တယ်၊ unbuffer ဆိုတာကတော့ immediately process လုပ်တယ် store မလုပ်ဘူးလို့ဆိုတယ်။
Buffered Channel
ch := make(chan int,2) data ကိုသိမ်းဖို့ size သတ်မှတ်ပေးရတယ်၊ receiver မရှိလည်း send လုပ်လို့ရတယ်။ block မလုပ်ဘူး။
buffer capacity ထက်ကျော်ပြီး send လုပ်ရင်တော့ deadlock ဖြစ်နိုင်တယ်။
Unbuffered Channel
ch := make(chan int)size သတ်မှတ်ပေးစရာမလိုဘူး၊ sender နဲ့ receiver နှစ်မျိုးစလုံး ready ဖြစ်တဲ့အထိ block လုပ်တယ်။ synchronize ဖြစ်တယ်ပေါ့။
Select Statement
channel operation တွေကို တစ်နေရာတည်းမှာတစ်ပြိုင်နက်တည်း handle လုပ်ချင်ရင် select statement ကိုသုံးရတယ်။
package main
import (
"fmt"
"time"
)
func main() {
c1 := make(chan string)
c2 := make(chan string)
go func() {
time.Sleep(1 * time.Second)
c1 <- "one"
}()
go func() {
time.Sleep(2 * time.Second)
c2 <- "two"
}()
for range 2 {
select {
case msg1 := <-c1:
fmt.Println("received", msg1)
case msg2 := <-c2:
fmt.Println("received", msg2)
}
}
}Synchronization and Safety
Concurrency မှာဆိုရင် race condition တွေရှိတဲ့အတွက် အဲ့ဒီကနေပေါ်လာတဲ့ ပြဿနာတွေလည်း ရှိလာမယ်။ အဲ့တာတွေကို နားလည်ထားရင် သတိထားနိုင်မယ်၊ ဖြေရှင်းလို့လွယ်မယ်ပေါ့။
အောက်မှာ Race condition နမူနာကိုကြည့်ပါ
package main
import (
"fmt"
"time"
)
func main(){
counter := 0
for i := 0; i < 1000; i++ {
go func (){
counter++
}()
}
time.Sleep(time.Second)
fmt.Println(counter) // Unpredictable result
}အဲ့လို shared resource ကိုတွေ concurrent access မဖြစ်အောင်ရယ် Synchronize ဖြစ်အောင်ရယ်ဆိုရင် sync package ရှိမယ် သူ့မှာ Mutex နဲ့ WaitGroup ဆိုတာရှိတယ်။ Mutex ကတော့ Mutual exclusion ပေါ့ resource တွေကို lock လုပ်ဖို့အတွက်သုံးတယ်၊ WaitGroup ကတော့ Synchronize လုပ်ဖို့ တစ်ခုပြီးမှ တစ်ခုလုပ်ဖို့ပေါ့။
package main
import (
"fmt"
"sync"
)
func main() {
var mu sync.Mutex
var wg sync.WaitGroup
counter := 0
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
mu.Lock()
counter++
mu.Unlock()
wg.Done()
}()
}
wg.Wait()
fmt.Println("Final counter value:", counter)
}
Atomic Operations
simple data type တွေအတွက် lock-free operation တွေကို sync/atomic package သုံးပြီးလုပ်လို့ရတယ်။ mutex တွေထက် simple operation တွေလုပ်တဲ့အခါမှာ ပိုမြန်တယ်၊ scope အကန့်အသတ်တော့ရှိမယ်။
package main
import (
"fmt"
"sync"
"sync/atomic"
)
func main() {
var counter int32
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
atomic.AddInt32(&counter, 1)
wg.Done()
}()
}
wg.Wait()
fmt.Println("Final counter value:", counter)
}
Common Pitfalls
Goroutine တွေမှာ developer တွေ သတိထားရမယ့် challenge တွေရှိတယ်
Goroutine Leaks
Goroutine တွေကို terminate မလုပ်မိတဲ့အခါမျိုးတွေမှာ resource တွေမလိုအပ်ဘဲ consume လုပ်နေတာမျိုးရှိနိုင်ပါတယ်။ အောက်ကနမူနာကိုကြည့်ပါ။
package main
func main() {
ch := make(chan int)
go func() {
<-ch // Blocks forever if no sender
}()
// select {}
// enable above line to see the deadlock situation
}ဒီလိုမျိုး leak တွေမဖြစ်အောင် exit condition တွေရှိရမယ်၊ မသုံးတော့တဲ့ channel တွေကို close လုပ်ပေးရမယ်၊ cancel လုပ်လို့ရတာတွေကိုလုပ်ပေးရမယ်။
Deadlocks from Unread Channels
Unbuffered channel ကို receiver မပါဘဲ အောက်မှာလို send တစ်ခုပဲ ပါတာမျိုး ဆို deadlock ဖြစ်မယ်၊ Unbuffered channel တွေသည် sender, receiver နှစ်ခုစလုံး ready မဖြစ်မချင်း block လုပ်မယ်ဆိုတာ အထက်မှာပြောခဲ့ပြီးသားဖြစ်ပါတယ်။
package main
func main() {
ch := make(chan int)
ch <- 1 // Deadlock: no receiver
}Best Practices
Limit Goroutines
Worker pools, Semiphores တွေသုံးပြီးတော့ Goroutine တွေကို limit လုပ်လို့ရပါတယ်။
worker pool example:
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
// process job
results <- j * 2
}
}
func main() {
const numWorkers = 3
jobs := make(chan int, 5)
results := make(chan int, 5)
for w := 1; w <= numWorkers; w++ {
go worker(w, jobs, results)
}
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)
for a := 1; a <= 5; a++ {
fmt.Println(<-results)
}
}Semiphores example:
sem := make(chan struct{}, 10) // allow max 10 goroutines at once
for _, task := range tasks {
sem <- struct{}{} // acquire
go func(t Task) {
defer func() { <-sem }() // release
process(t)
}(task)
}Use Context
context ကိုသုံးပြီးတော့ cancellation, timeout တွေ လုပ်လို့ရမယ်။
package main
import (
"context"
"fmt"
"time"
)
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
ch := make(chan string)
go func() {
select {
case <-ctx.Done():
fmt.Println("Goroutine: context canceled")
case ch <- "Task complete":
fmt.Println("Goroutine: sent task result")
}
}()
time.Sleep(3 * time.Second)
}Favor Message Passing
Goroutine တွေသုံးပြီး message passing နဲ့ data ကို share လို့ရမယ်။ shared memory သုံးတာကိုတတ်နိုင်သလောက်ရှောင်။
Do not communicate by sharing memory; instead, share memory by communicating.
Close Channels
Data ပို့တာမျိုးမလုပ်တော့ဘူးဆိုရင် Close လုပ်သင့်တဲ့ channel ကိုလုပ်ပါ။ မဟုတ်ရင် resource leak တာတွေ deadlock ပြဿနာတွေကြုံရပါလိမ့်မယ်။
Real-World Use Cases
Goroutines တွေကို web servers တွေမှာ concurrent requests တွေကို handle လုပ်ဖို့သုံးတယ်၊
Background task တွေ လုပ်ဖို့သုံးတယ်၊ Parallel processing လုပ်တဲ့နေရာတွေမှာ အဓိကသုံးတယ်။
သိထားသင့်တဲ့ tools တွေဘာတွေရှိမလဲဆိုရင် Race detector ရှိမယ်၊ Tracing and Profiling လုပ်ဖို့အတွက်သုံးတာတွေ၊ Runtime Diagnostics လုပ်တာတွေသိထားဖို့လိုမယ်။
Race Detector
Data race တွေကို အောက်က CLI နဲ့ detect လုပ်နိုင်တယ်။
go run -race main.goTracing
အောက်က CLI ကိုသုံးပြီး Goroutine scheduling နဲ့ bottlenecks တွေကို visualize လုပ်လို့ရတယ်။
go tool trace Profiling
pprof ကိုသုံးပြီး CPU, memory usage တွေကို monitor လုပ်လို့ရမယ်။
အောက်က program ကို run ထားပြီး http://localhost:6060/debug/pprof မှာ profile တွေကြည့်လို့ရတယ်။
package main
import (
"net/http"
_ "net/http/pprof"
)
func main() {
go func() {
// Starts the pprof HTTP server on default port 6060
http.ListenAndServe("localhost:6060", nil)
}()
// Program logic
}Runtime Diagnostics
ဒီအတွက်ကတော့ runtime.NumGoroutine() သုံးပြီး active Goroutines တွေ၊ leak ဖြစ်နေတာတွေကို monitor လုပ်လို့ရတယ်။
နိဂုံးချုပ်ရရင် Go Concurrency Model မှာ Goroutine တွေကအခြေခံအကျဆုံးဖြစ်တာမလို့ သေချာ နားလည်ထားဖို့လိုပါတယ်။
Last updated