Cad a bhíonn i gcúis dhíbhreathnú goroutine agus conas a bhraistí tú iad?

Question

Accepted Answer

**Díbhreachaint goroutine** atá ann nuair a bhíonn goroutine ann nach deireadh a bhíonn aige — fanann sé gafa nó ag rith go deo, ag ithe cuimhne (agus ag coimeád a oibreirí in-thagartha beo) ar feadh saoil an chláir. Ós rud é go bhfuil goroutines saor chun a thosú, is éasca iad a dhíbhreachaint, agus cumailt na dílíonadh go ciúin go dtí go laghdaítear an seirbhís nó go n-íosfar an chuimhne.

## Cúis 1: gafa ar chanal gan seoltóir/faighteoir

```go
// ❌ LEAK — this goroutine blocks forever waiting to send
func leak() {
    ch := make(chan int)   // unbuffered
    go func() {
        ch <- 42           // blocks forever — NOBODY ever receives
    }()                     // the goroutine is stuck, never exits
    // function returns without reading ch → the goroutine leaks
}
```

Goroutine gafa ar sheoladh/fháil canal nach críochnaíonn go deo beidh sé ag feitheamh **go deo** — ní ghlantar ar an tasc go deo mar tá sé fós "ag rith" go teicniúil.

## Cúis 2: gan chealúchán / comhartha críochnaithe

```go
// ❌ LEAK — a goroutine in an infinite loop with no way to stop
func worker(jobs <-chan int) {
    for {
        job := <-jobs      // blocks forever if jobs is never closed and stops sending
        process(job)
    }                       // no exit condition — leaks when no longer needed
}
```

## Cosc 1: úsáid context don chealúchán

```go
// ✅ the goroutine can be told to stop
func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-ctx.Done():       // cancellation signal → exit cleanly
            return                // the goroutine terminates, no leak
        }
    }
}
// caller: ctx, cancel := context.WithCancel(...); defer cancel()
```

An bealach a thabhairt do gach goroutine fada-bheo a chealúchán (`<-ctx.Done()`) an príomhdhifríonn é — cinntíonn sé go dtéann goroutines i gcríoch nuair nach bhfuil a gcuid oibre de dhíth a thuilleadh.

## Cosc 2: úsáid cainéal foluain nó cinntigh go bhfuil faighteoirí ann

```go
// ✅ ensure a receiver exists, or use a buffered channel so the send doesn't block
ch := make(chan int, 1)   // buffered → the send completes even if no one receives yet
go func() { ch <- 42 }()   // doesn't block
```

## Cosc 3: dún cainéil go deo / driomaigh iad i gceart

```go
// ✅ close channels so range loops terminate
go func() {
    defer close(results)    // signal completion → for-range over results ends
    for _, job := range jobs { results <- process(job) }
}()
```

## Dí-bhreachaintí a bhrath

```go
runtime.NumGoroutine()         // monitor the goroutine count — steady growth = leak
import _ "net/http/pprof"      // pprof exposes goroutine stacks (/debug/pprof/goroutine)
// the goleak library asserts no leaked goroutines in tests
```

Monitóireacht ar `runtime.NumGoroutine()` (ríomh ag imeall go soiléir comhartha dí-bhreachaint), iniúchadh dhumpai goroutine trí `pprof`, agus úsáid `goleak` i dtrialachais an príomh-uirlisí bhraistthe.

## An fáth ar a bhfuil sé tábhachtach

Is iad dí-bhreachaintí goroutine ceann de na fadhbanna is coitianta agus is doilbhéasach i seirbhísí Go táirgthe.

Toisc go bhfuil goroutines chomh saor chun a sheoladh, cruthraíonn forbróirí iad go saor — ach goroutine gafa go deo (ar chanal gan chómhalarthaí, nó i lúb gan deireadh gan chealúchán) **ní theirgeann sé go deo agus ní scaoileanns sé a chuimhne** (an méid ar fad a bhíonn sé ag tagairt dó).

I bhfreastalaí fadthréimhseach, cumailt na dílíonadh go ciúin, ag ithe cuimhne go mall go dtí go laghdaítear an seirbhís nó go dtiteann sé - agus is deacair iad a bhrath toisc nach bhfuil earráid láithreach ann.

An tuiscint ar na cúiseanna (oibríochtaí chanal gafa, cealúchán ar iarraidh) agus na coisceananna (**cealúchán bunaithe ar chomhthéacs** mar an príomhdhifríonn, dúnadh cainte i gceart, cainéal foluain, cinntigh go bhfuil faighteoirí ann) a bheith riachtanach chun Go comhthreomhar iontaofa a scríobh.

An fhios a bheith agat ar an uirlisí bhraistthe (`runtime.NumGoroutine`, pprof, goleak) a bheith chomh tábhachtach.

Is ábhar criticiúil, minic-thástáilte atá ann a dhéanann scaradh idir forbróirí ar féidir leo Go comhthreomhar táirgthe a scríobh agus iad sin a scríobh cód a dhíbhreachann faoi ualach foluain.