Goroutine என்பது Go runtime இல் நிர்வகிக்கப்படும் ஒரு இலகுவான, நிகழ்செயலாக செயல்படும் function ஆகும். ஒன்றைத் தொடங்குவது function call க்கு முன் go சேர்ப்பதைப் போல எளிமையாக உள்ளது. Goroutine கள் Go இன் கையொப்ப concurrent feature ஆகும் — OS threads ஐ விட மிகவும் குறைந்த செலவு, எனவே நீங்கள் ஆயிரம் அல்லது மில்லியன் கணக்கில் இயக்கலாம்.
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
go keyword புதிய goroutine இல் function ஐ தொடங்கி உடனடியாக திரும்பி வருகிறது — அழைக்கும் 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).
Goroutine கள் OS threads அல்ல — Go scheduler பல goroutine களை சில OS threads இல் பெருக்குகிறது. இது அவற்றை அசாধாரணமாக குறைந்த செலவுள்ளதாக ஆக்குகிறது, பெரிய அளவிலான concurrency ஐ செயல்படுத்த அனுமதிக்கிறது (எ.கா. ஒரு server இல் மில்லியன் connections ஐ கையாளும் போது ஒரு connection க்கு ஒரு goroutine).
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
main திரும்பிய போது, program முடிவடைகிறது — இன்னும் இயங்கும் goroutine களை அழித்தல். நீங்கள் 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 என்பது goroutine களின் ஒரு set முடிந்ததற்கு காத்திருப்பதற்கான standard வழி ஆகும்.
ch := make(chan string)
go func() { ch <- "result" }() // send a result on the channel
msg := <-ch // receive (blocks until a value arrives)
Go philosophy: "Memory ஐ பகிர்ந்துகொண்டு தொடர்புகொள்ளாதீர்கள்; communication மூலம் memory ஐ பகிர்ந்துகொள்ளுங்கள்" — shared variables + locks க்கு பதிலாக goroutine களுக்கு இடையில் data ஐ pass செய்ய channels ஐ பயன்படுத்தவும்.
Goroutine கள் Go இன் வரையறுக்கும் feature ஆகும் மற்றும் இது concurrent, networked systems இல் excels என்பதற்கான முக்கிய காரணம் ஆகும்.
அவற்றின் extreme lightness (threads க்கு megabytes க்கு எதிரான kilobytes, OS threads இன் மீது M:N scheduled) பெரிய அளவிலான concurrency ஐ நடைமுறைக்ற மற்றும் எளிமையாக ஆக்குகிறது — ஒரு server resource concerns இல்லாமல் ஒரு request அல்லது connection க்கு ஒரு goroutine ஐ spawn செய்யலாம், இது OS threads உடன் hard அல்லது impossible ஆகும்.
அவற்றை எவ்வாறு தொடங்குவது (go), synchronize செய்வதற்கான முக்கியமான தேவை (main exiting goroutine களை அழிக்கிறது; காத்திருப்பதற்கு WaitGroup ஐ பயன்படுத்தவும்), மற்றும் shared memory இன் மீது channels மூலம் communicating করும் Go இன் preference ஐ புரிந்துகொள்ளுதல் சரியான concurrent Go ஐ எழுதுவதற்கு அடிப்படையாக உள்ளது.
Goroutine கள் (மற்றும் அவற்றைச் சுற்றியுள்ള patterns) Go இன் value proposition க்கு மையமாக உள்ளது மற்றும் language இல் மிக முக்கியமான மற்றும் அடிக்கடி-tested topics களுக்கு இடையில் உள்ளது.