గోరౌటిన్‌లు (goroutines) అంటే ఏమిటి?

Question

Accepted Answer

ఒక **goroutine** Go రన్‌టైమ్ ద్వారా నిర్వహించబడే తేలికైన, సమకాలీనంగా నిర్వహించే ఫంక్షన్. ఒకదానిని ప్రారంభించడం చాలా సులభం — ఫంక్షన్ కాల్ కు ముందు `go` ఉంచండి. గోరౌటిన్‌లు Go యొక్క సంతకం సమకాలీనత లక్షణం — OS థ్రెడ్‌ల కంటే చాలా చవకైనవి, కాబట్టి మీరు వేలవేల లేదా మిలియన్ల నలిక రన్ చేయవచ్చు.

## గోరౌటిన్‌ను ప్రారంభించడం

```go
func sayHello() {
    fmt.Println("Hello from a goroutine")
}

go sayHello()        // launch concurrently — main does NOT wait for it
go func() {           // or an anonymous function
    fmt.Println("inline goroutine")
}()
```

`go` కీవర్డ్ ఫంక్షన్‌ను కొత్త గోరౌటిన్‌లో ప్రారంభిస్తుంది మరియు వెంటనే రిటర్న్ చేస్తుంది — కాలింగ్ కోడ్ వేచి ఉండకుండా కొనసాగుతుంది.

## గోరౌటిన్‌లు ప్రత్యేకమైనది: అవి చవకైనవి

```text
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 థ్రెడ్‌లపై మల్టిప్లెక్స్ చేస్తుంది. ఇది వాటిని అసాధారణంగా చవకుగా చేస్తుంది, విशాల సమకాలీనతను ప్రారంభం చేస్తుంది (ఉదా. మిలియన్ల కనెక్షన్‌లను నిర్వహించే సర్వర్‌లో ప్రతి కనెక్షన్‌కు ఒక గోరౌటిన్).

## సమన్వయం సమస్య: main చాలా త్వరగా నిష్క్రమించవచ్చు

```go
func main() {
    go sayHello()    // ❌ main might EXIT before this goroutine runs → nothing printed
    // program ends immediately
}
```

`main` రిటర్న్ చేసినప్పుడు, ప్రోగ్రామ్ ముగుస్తుంది — ఇప్పటికీ నిర్వహణ చేయుటలో ఉన్న గోరౌటిన్‌లను చంపుతుంది. మీరు సమన్వయం చేయవలసి ఉంది.

## sync.WaitGroup తో వేచి ఉండటం

```go
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` గోరౌటిన్‌ల సమితి పూర్తి చేయటకు వేచియుండటానికి ప్రామాణిక మార్గం.

## చానెల్‌ల ద్వారా సమాచారం చెప్పడం

```go
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 యొక్క విలువ ప్రతిపాదన యొక్క కేంద్రం మరియు భాష లో చాలా ముఖ్యమైన మరియు తరచుగా-పరీక్ష చేయబడిన విషయాలలో ఒకటి.