ગોરૂટીન એક હલકો, સમવર્તી રીતે એક્ઝીક્યુટ થતો ફંક્શન છે જે Go રનટાઇમ દ્વારા સંચાલિત થાય છે. એક લાંચ કરવો એટલો સરળ છે કે ફંક્શન કૉલ પહેલાં go મૂકી દો. ગોરૂટીન્સ Go નું સિગ્નેચર કન્કરન્સી ફીચર છે — OS થ્રેડ્સ કરતાં ઘણું સાસ્તું, તેથી તમે હજારો અથવા લાખો ચલાવી શકો છો.
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
go કીવર્ડ ફંક્શนને નવા ગોરૂટીન પર શરૂ કરે છે અને તરત જ પાછું આવે છે — કૉલિંગ કોડ વાટ કર્યા વિના આગળ વધે છે.
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).
ગોરૂટીન્સ OS થ્રેડ્સ નથી — Go શેડ્યુલર ઘણા ગોરૂટીન્સને થોડા OS થ્રેડ્સ પર મલ્ટીપ્લેક્સ કરે છે. આ તેમને અત્યંત સાસ્તું બનાવે છે, વિશાળ કન્કરન્સી સક્ષમ કરે છે (દા.ત. એક સર્વર જે લાખોના જોડાણો સંભાળે તો પ્રતિ જોડાણ માટે એક ગોરૂટીન).
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
જ્યારે main વળતું આવે છે, ત્યારે પ્રોગ્રામ સમાપ્ત થાય છે — કોઈ પણ હજુ ચલતા ગોરૂટીન્સને માર નાખે છે. તમે સમન્વય કરવાની જરૂર છે.
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 એ ગોરૂટીન્સના સમૂહ સમાપ્ત થવાની રાહ જોવાનો પ્રમાણભૂત રીત છે.
ch := make(chan string)
go func() { ch <- "result" }() // send a result on the channel
msg := <-ch // receive (blocks until a value arrives)
Go ફિલોસોફી: "મેમરી શેર કરીને સંચાર ન કરો; સંચાર કરીને મેમરી શેર કરો" — ગોરૂટીન્સ વચ્ચે ડેટા પાસ કરવા માટે ચેનલ્સ ઉપયોગ કરો, શેર કરેલ વેરિયબલ્સ + લૉક્સ બદલે.
ગોરૂટીન્સ Go નું વ્યાખ્યાયિત ફીચર છે અને તે સમવર્તી, નેટવર્ક્ડ સિસ્ટમ્સમાં શ્રેષ્ઠ છે તેનું મુખ્ય કારણ છે.
તેમની અત્યંત હલકી પ્રકૃતિ (થ્રેડ્સ માટે મેગાબાઇટ્સ વર્સ કિલોબાઇટ્સ, OS થ્રેડ્સ પર M:N શેડ્યુલ કરાયેલ) વિશાળ કન્કરન્સી પ્રાયોગિક અને સરળ બનાવે છે — એક સર્વર રિસોર્સ ચિંતા વિના પ્રતિ રિક્વેસ્ટ અથવા જોડાણ માટે ગોરૂટીન સ્પાન કરી શકે છે, જે OS થ્રેડ્સ સાથે મુશ્કેલ અથવા અશક્ય છે.
તેમને કેવી રીતે લાંચ કરવું (go), સિંક્રોનાઈજ કરવાની નિર્ણયક જરૂરિયાત (main બહાર નીકળવું ગોરૂટીન્સને માર નાખે છે; રાહ જોવા માટે WaitGroup ઉપયોગ કરો), અને શેર કરેલ મેમરી પર ચેનલ્સ દ્વારા સંચાર કરવાની Go ની પસંદગી સમજવું Go માં સાચો સમવર્તી કોડ લખવા માટે મૌલિક છે.
ગોરૂટીન્સ (અને તેમની આશપાશની પેટર્ન્સ) Go નું મૂલ્ય પ્રસ્તાવ માટે કેન્દ્રીય છે અને ભાષામાં સૌથી મહત્વપૂર્ણ અને વારંવાર પરીક્ષણ કરાતા વિષયોમાંથી છે.