Goroutines म्हणजे काय?

Question

Accepted Answer

**goroutine** हा Go runtime द्वारे व्यवस्थापित एक हलका, एकाधिक कार्य करणारा फंक्शन आहे. एक लाँच करणे सोपे आहे - फंक्शन कॉल करण्यापूर्वी फक्त `go` ठेवा. Goroutines हे Go चे वैशिष्ट्यपूर्ण concurrency वैशिष्ट्य आहे — OS threads पेक्षा बरेच स्वस्त, म्हणून तुम्ही हजारो किंवा लाखो चालवू शकता.

## Goroutine लाँच करणे

```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` की-वर्ड नवीन goroutine वर फंक्शन सुरू करते आणि तत्काळ परत येते — कॉल करणारा कोड प्रतीक्षा न करता चालू राहतो.

## Goroutines विशेष का आहेत: ते स्वस्त आहेत

```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).
```

Goroutines OS threads नाहीत — Go scheduler अनेक goroutines ला काही OS threads वर multiplex करते. हे त्यांना अत्यंत स्वस्त बनवते, विशाल concurrency सक्षम करते (उदा. सर्व्हर मध्ये प्रत्येक कनेक्शन साठी एक goroutine जो लाखो कनेक्शन हाताळते).

## Synchronization समस्या: main खूप लवकर बंद होऊ शकते

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

जेव्हा `main` परत येते, प्रोग्राम समाप्त होतो — अजूनही चालू असलेल्या सर्व goroutines मारते. समन्वय आवश्यक आहे.

## 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` goroutines च्या संचाच्या पूर्ण होण्याची प्रतीक्षा करण्याचा मानक मार्ग आहे.

## Channels द्वारे संप्रेषण

```go
ch := make(chan string)
go func() { ch <- "result" }()   // send a result on the channel
msg := <-ch                       // receive (blocks until a value arrives)
```

Go तत्वज्ञान: **"मेमोरी शेअर करून संप्रेषण करू नका; संप्रेषण करून मेमोरी शेअर करा"** — शेअर केलेल्या व्हेरिएबल्स + locks ऐवजी goroutines मध्ये डेटा पास करण्यासाठी channels वापरा.

## हे का महत्वाचे आहे

Goroutines हे Go चे परिभाषित वैशिष्ट्य आहे आणि हे concurrent, networked सिस्टममध्ये उत्कृष्ट असण्याचे मुख्य कारण आहे.

त्यांची अत्यंत हल्कीपणा (threads साठी megabytes विरुद्ध kilobytes, OS threads वर M:N अनुसूचित) विशाल concurrency व्यावहारिक आणि सहज बनवते — सर्व्हर संसाधनांच्या चिंता न करता प्रत्येक request किंवा कनेक्शनसाठी goroutine सुरू करू शकते, जे OS threads सह कठीण किंवा अशक्य आहे.

त्यांना कसे सुरू करायचे (`go`), **synchronize** करण्याची महत्वाची गरज (main बंद केल्याने goroutines मारले जाते; प्रतीक्षा करण्यासाठी `WaitGroup` वापरा), आणि शेअर केलेल्या मेमोरी ऐवजी **channels द्वारे संप्रेषण** करण्याचे Go चे प्राधान्य हे योग्य concurrent Go लिहिण्यासाठी मूलभूत आहे.

Goroutines (आणि त्यांच्या सभोवती पॅटर्न) Go च्या मूल्य प्रस्तावचे केंद्र आहेत आणि भाषामधील सर्वात महत्वाचे आणि वारंवार-परीक्षित विषय आहेत.