एक goroutine एक हल्का, समानांतर रूप से चलने वाला function है जिसे Go runtime प्रबंधित करता है। इसे लॉन्च करना उतना ही सरल है जितना किसी function call से पहले go लगाना। Goroutines Go की हस्ताक्षर concurrency विशेषता हैं — OS threads से कहीं सस्ती, इसलिए आप हज़ारों या लाखों चला सकते हैं।
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
go keyword function को एक नई goroutine पर शुरू करता है और तुरंत return कर देता है — calling code बिना प्रतीक्षा किए आगे बढ़ता है।
OS thread: ~1–2 MB of memory each → thousands max
Goroutine: ~2 KB initial stack (grows as needed) → MILLIONS feasible
The Go runtime SCHEDULES many goroutines onto a small pool of OS threads (M:N).
Goroutines OS threads नहीं हैं — Go scheduler कई goroutines को कुछ OS threads पर multiplex करता है। इससे वे असाधारण रूप से सस्ती हो जाती हैं, जो बड़े पैमाने की concurrency संभव बनाता है (जैसे लाखों connections संभालने वाले server में प्रति connection एक goroutine)।
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
जब main return करता है, program समाप्त हो जाता है — किसी भी अभी भी चल रही goroutines को मार देता है। आपको coordinate करने की ज़रूरत है।
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Add(1) // increment the counter
go func(n int) {
defer wg.Done() // decrement when this goroutine finishes
fmt.Println("worker", n)
}(i) // pass i as an argument (avoid the loop-var capture bug)
}
wg.Wait() // BLOCK until all goroutines call Done()
sync.WaitGroup goroutines के एक समूह के पूरा होने की प्रतीक्षा करने का मानक तरीका है।
ch := make(chan string)
go func() { ch <- "result" }() // send a result on the channel
msg := <-ch // receive (blocks until a value arrives)
Go का दर्शन: "Don't communicate by sharing memory; share memory by communicating" — goroutines के बीच data पास करने के लिए shared variables + locks के बजाय channels का उपयोग करें।
Goroutines Go की परिभाषक विशेषता हैं और मुख्य कारण कि यह concurrent, networked systems में उत्कृष्ट है।
इनका अत्यधिक हल्कापन (threads के megabytes बनाम kilobytes, OS threads पर M:N scheduled) बड़े पैमाने की concurrency को व्यावहारिक और आसान बनाता है — एक server संसाधनों की चिंता के बिना प्रति request या connection एक goroutine spawn कर सकता है, जो OS threads के साथ कठिन या असंभव है।
इन्हें लॉन्च करना (go), synchronize करने की महत्वपूर्ण आवश्यकता (main का exit goroutines को मार देता है; प्रतीक्षा के लिए WaitGroup का उपयोग करें), और shared memory पर channels के माध्यम से संवाद करने की Go की प्राथमिकता को समझना सही concurrent Go लिखने के लिए बुनियादी है।
Goroutines (और इनके इर्द-गिर्द के पैटर्न) Go के मूल्य-प्रस्ताव के केंद्र में हैं और भाषा में सबसे महत्वपूर्ण और अक्सर परखे जाने वाले विषयों में से हैं।