goroutines भनेको के हो?

Question

Accepted Answer

एक **goroutine** Go runtime द्वारा व्यवस्थापित एक हल्का, समवर्ती-निष्पादन गर्ने प्रकार्य हो। एउटा सुरु गर्न प्रकार्य कल गर्नुअघि `go` लगाउनु जत्तिकै सरल छ। Goroutines Go को हस्ताक्षर समवर्ती विशेषता हो — 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 मा multiplexes गर्छ। यसले तिनीहरूलाई असाधारण रुपमा सस्तो बनाउँछ, विशाल समवर्ती सक्षम पारिँदै (जस्तै एक सर्भरमा एक जडान प्रति एक goroutine जसले लाखौं जडान हेरिरहेको छ)।

## समन्वय समस्या: 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 दर्शन: **