ਇੱਕ goroutine Go runtime ਦੁਆਰਾ ਪ੍ਰਬੰਧਤ ਇੱਕ lightweight, concurrently-executing ਫੰਕਸ਼ਨ ਹੈ। ਇੱਕ ਲਾਂچ ਕਰਨਾ ਬਹੁਤ ਸਧਾਰਨ ਹੈ — ਸਿਰਫ਼ go ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਤੋਂ ਪਹਿਲਾਂ ਰੱਖੋ। Goroutines Go ਦੀ ਖਾਸ concurrency ਵਿਸ਼ੇਸ਼ਤਾ ਹਨ — OS threads ਨਾਲੋਂ ਬਹੁਤ ਸਸਤੇ, ਇਸ ਲਈ ਤੁਸੀਂ ਹਜ਼ਾਰਾਂ ਜਾਂ ਲੱਖਾਂ ਚਲਾ ਸਕਦੇ ਹੋ।
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
go keyword ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਨਵੇ goroutine ਤੇ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਰੰਤ ਵਾਪਸ ਕਰਦਾ ਹੈ — ਕਾਲ ਕਰਨ ਵਾਲਾ ਕੋਡ ਬਿਨਾਂ ਰੁਕੇ ਜਾਰੀ ਰਹਿੰਦਾ ਹੈ।
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 ਕਰਦਾ ਹੈ। ਇਹ ਉਨ੍ਹਾਂ ਨੂੰ ਅਸਾਧਾਰਨ ਤੌਰ 'ਤੇ ਸਸਤਾ ਬਣਾਉਂਦਾ ਹੈ, massive concurrency ਨੂੰ ਸਮਰੱਥ ਕਰਦਾ ਹੈ (ਉਦਾ. ਮਿਲੀਅਨ connections ਹੈਂਡਲ ਕਰਨ ਵਾਲੇ ਸਰਵਰ ਵਿੱਚ ਪ੍ਰਤੀ connection ਲਈ ਇੱਕ goroutine)।
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
ਜਦ main ਵਾਪਸੀ ਕਰਦਾ ਹੈ, ਪ੍ਰੋਗ੍ਰਾਮ ਖਤਮ ਹੁੰਦਾ ਹੈ — ਕਿਸੇ ਵੀ ਅਜੇ ਚੱਲ ਰਹੇ 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 ਦਰਸ਼ਨ: "ਮੈਮੋਰੀ ਸ਼ਾਂਨਦਾ ਕੇ ਸੰਚਾਰ ਨਾ ਕਰੋ; ਸੰਚਾਰ ਕੇ ਮੈਮੋਰੀ ਸਾਂਝੀ ਕਰੋ" — goroutines ਵਿਚਕਾਰ ਡੇਟਾ ਪਾਸ ਕਰਨ ਲਈ shared variables + locks ਦੀ ਬਜਾਏ channels ਵਰਤੋ।
Goroutines Go ਦੀ ਪਰਿਭਾਸ਼ਾਤਮਕ ਵਿਸ਼ੇਸ਼ਤਾ ਹਨ ਅਤੇ ਮੁੱਖ ਕਾਰਨ ਕਿ ਇਹ concurrent, networked ਸਿਸਟਮਾਂ ਵਿੱਚ ਉਤਕ੍ਰਿਸ਼ਟ ਹੈ।
ਉਹਨਾਂ ਦੀ ਬਹੁਤ ਹੀ lightweight ਪ੍ਰਕ੍ਰਿਤੀ (threads ਲਈ megabytes ਬਨਾਮ kilobytes, OS threads ਤੇ M:N ਤੌਰ 'ਤੇ scheduled) massive concurrency ਨੂੰ ਵਿਹਾਰਕ ਅਤੇ ਸਆਦੀ ਬਣਾਉਂਦੀ ਹੈ — ਇੱਕ ਸਰਵਰ ਪ੍ਰਤੀ request ਜਾਂ connection ਲਈ ਇੱਕ goroutine ਤੈਨਾਤ ਕਰ ਸਕਦਾ ਹੈ ਬਿਨਾਂ resource concerns ਦੇ, ਜੋ OS threads ਨਾਲ ਮੁਸ਼ਕਲ ਜਾਂ ਅਸੰਭਵ ਹੈ।
ਸਮਝਣਾ ਕਿ ਕਿਵੇਂ ਉਨ੍ਹਾਂ ਨੂੰ ਲਾਂਚ ਕਰਨਾ ਹੈ (go), synchronize ਕਰਨ ਦੀ ਮਹੱਤਵਪੂਰਨ ਜ਼ਰੂਰਤ (main ਬਾਹਰ ਨਿਕਲਣਾ goroutines ਮਾਰਦਾ ਹੈ; ਉਡੀਕ ਕਰਨ ਲਈ WaitGroup ਵਰਤੋ), ਅਤੇ Go ਦੀ shared memory ਦੀ ਬਜਾਏ channels ਦੁਆਰਾ ਸੰਚਾਰ ਦੀ ਤਰਜੀਹ correct concurrent Go ਲਿਖਣ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।
Goroutines (ਅਤੇ ਉਹਨਾਂ ਦੇ ਆਲੇ ਦੁਆਲੇ ਦੇ ਪੈਟਰਨ) Go ਦੇ value proposition ਲਈ ਕੇਂਦਰੀ ਹਨ ਅਤੇ ਭਾਸ਼ਾ ਵਿੱਚ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਅਤੇ ਅਕਸਰ-ਟੈਸਟ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਵਿਸ਼ਿਆਂ ਵਿੱਚ ਹਨ।