Goroutines: இலகுரக பேரலலிசம்

A goroutine என்பது Go ஆல் நிர்வகிக்கப்படும் ஒரே நேரத்தில் செயல்படுத்தும் அலகு ஆகும் இயக்க நேரம். செயல்பாட்டின் முன் go முக்கிய சொல்லுடன் ஒன்றைத் தொடங்குகிறீர்கள் அழைப்பு:

go greet("Anna")         // chiamata a funzione esistente
go func() {              // funzione anonima
    fmt.Println("hi")
}()

go அறிக்கை உடனடியாக: goroutine தொடங்குகிறது இணையாக மற்றும் அழைப்பவர் தொடர்ந்து செல்கிறார்.

அவை ஏன் "இலகுரக"

• இனிஷியல் ஸ்டாக் ~2KB (தேவைப்பட்டால் நூற்றுக்கணக்கான எம்பி வரை மாறும்).
• மல்டிப்ளெக்ஸ் இயக்க நேரத்தின்படி குறைந்த எண்ணிக்கையிலான OS த்ரெட்களில் (GOMAXPROCS).
• ஆயிரக்கணக்கான/மில்லியன் கோருட்டீன்கள் வழக்கமானவை; OS நூல்கள் மூலம் அவை சாத்தியமற்றதாக இருக்கும்.

கருத்துரீதியாக இது "ஒரே நேரத்தில் தீ மற்றும் மறந்து", ஆனால் அனைத்து ஒருங்கிணைக்க மொழியியல் கருவிகள் (சேனல்கள், sync.WaitGroup, context).

முக்கிய காத்திருக்கவில்லை

func main() {
    go func() { fmt.Println("ciao dalla goroutine") }()
    // main esce subito: niente garanzia che la goroutine completi
}

main திரும்பும்போது, செயல்முறை முடிவடைகிறது: goroutines பெறவில்லை "தங்கள் வேலையை முடிக்க", அவர்கள் வெறுமனே ஒன்றாக கொல்லப்படுகிறார்கள் செயல்முறை. வெளிப்படையான ஒத்திசைவு தேவை.

ஒத்திசைவு: ஒரு முன்னோட்டம்

அடுத்த பாடங்களில் நீங்கள் பார்க்கும் மூன்று கருவிகள்:

// 1) Channel: la goroutine "segnala" via canale
done := make(chan struct{})
go func() {
    work()
    done <- struct{}{}
}()
<-done   // attendi

// 2) sync.WaitGroup: N goroutine
var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done(); work() }()
wg.Wait()

// 3) context: cancellazione/timeout propagati

"கிளாசிக்" க்ளோசர்-இன்-லூப் பிழை

கோ 1.21 வரை இது அடிக்கடி கேட்கப்பட்டது:

for i := 0; i < 3; i++ {
    go func() { fmt.Println(i) }()  // stampa "3 3 3" su versioni vecchie
}

Go 1.22 இலிருந்து for மாறி ஒவ்வொன்றிலும் புதிதாக உருவாக்கப்பட்டது மறு செய்கை, எனவே பிழை இயல்பாகவே சரி செய்யப்பட்டது. பழைய கோட்பேஸ்களில் நீங்கள் செய்வீர்கள் இன்னும் சரிசெய்தல் வடிவத்தைக் காண்க:

for i := 0; i < 3; i++ {
    i := i           // shadow esplicito
    go func() { fmt.Println(i) }()
}
// oppure passa come argomento:
for i := 0; i < 3; i++ {
    go func(n int) { fmt.Println(n) }(i)
}

Goroutine != OS நூல்

ஒரு OS நூல் பல goroutineகளை ஹோஸ்ட் செய்யலாம். இயக்க நேரம் நகர்கிறது தேவைப்படும் போது நூல் முழுவதும் goroutines.

முயற்சி செய்து பாருங்கள்

func main() {
  go work()
  // main ritorna immediatamente
}

மறுபரிசீலனை

• go f() f()ஐ ஒரே நேரத்தில் துவக்குகிறது; அது உடனடியாக திரும்பும்.
• Goroutine = ~2 KB இன்ஷியல், ஒரு சில OS த்ரெட்களில் மல்டிபிளக்ஸ் செய்யப்பட்டது.
• main காத்திருக்கவில்லை: உங்களுக்கு ஒத்திசைவு தேவை (channel/WaitGroup/context).
• time.Sleep என்பது செயற்கையான செயல் மட்டுமே, தயாரிப்பில் ஒத்திசைக்கப்படாது.
• Go 1.22 இலிருந்து for மாறி ஒவ்வொரு மறு செய்கையிலும் "புதியது" (இனி "3 3 3" பிழை இல்லை).