goroutine არის მცირე წონის, ერთდროულად შესრულებული ფუნქცია, რომელსაც ზედამხედელობს Go runtime. მისი გაშვება მარტივია - ფუნქციის გამოძახების წინ მხოლოდ go დაწერეთ. Goroutines არის Go-ს ხელმოწერილი concurrency ფიচა — ბევრად უფრო იაფი ვიდრე OS threads, ამიტომ შეგიძლიათ ათასობით ან მილიონობით გაშვება.
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
go საკვანძო სიტყვა აწყობს ფუნქციას ახალ 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-ი მრავალ goroutine-ს ასახელებს რამდენიმე OS thread-ზე. ეს მათ უკიდურესად იაფს ხდის, რაც შესაძლებელს ხდის 거대한concurrency-ს (მაგ. ერთი goroutine თითოეული კავშირი სერვერში რომელიც მილიონობით კავშირს განკუთვნის).
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
როდესაც main დაბრუნდება, პროგრამა სრულდება — მოკლავს ყველა ჯერ კიდევ მუშა goroutine-ს. საჭიროა კოორდინაცია.
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 არის სტანდარტული გზა goroutine-ების ნაკრებით ელოდება.
ch := make(chan string)
go func() { ch <- "result" }() // send a result on the channel
msg := <-ch // receive (blocks until a value arrives)
Go-ს ფილოსოფია: "არ კომუნიცირებთ მეხსიერების გაზიარებით; გაზიარებთ მეხსიერებას კომუნიკაციის საშუალებით" — გამოიყენეთ channels მონაცემთა გამოცემისთვის goroutine-ებს შორის ვიდრე გაზიარებული ცვლადების + locks.
Goroutines არის Go-ს განმსაზე მკრთალი ფიჩა და ძირითადი მიზეზი რომ Go წარმატებული იყოს concurrent, networked სისტემებში.
მათი უკიდურესი მსუბუქი წონა (kilobytes vs megabytes threads-ისთვის, გაკვეთილი M:N-ზე OS threads-ზე) ხდის 거대한concurrency-ს პრაქტიკულ და მარტივ — სერვერმა შეუძლია goroutine-ი თითოეული request ან კავშირი რესურსების შინაგან წინააღმდეგობის გარეშე, რომელიც ძნელი ან შეუძლებელი არის OS threads-ით.
გაცნობიერება თუ როგორ გაშვება მათი (go), კრიტიკული საჭიროება სინქრონიზაციისთვის (main დასრულება მოკლავს goroutines; გამოიყენეთ WaitGroup ელოდებისთვის), და Go-ს უპირატესობა კომუნიკაციისთვის channels-ით გაზიარებული მეხსიერების მაგივრად არის ფუნდამენტური სწორი concurrent Go დაწერისთვის.
Goroutines (და მათი პერიმეტრის პატერნები) არის ცენტრალური Go-ს მნიშვნელობის წინადადებაში და ყველაზე მნიშვნელოვანი და ხშირად-ტესტირებული თემები ენაში.