X'inhuma goroutines?

Question

Accepted Answer

**goroutine** hija funzjoni ħafifa, li tiġi eżekwita fl-istess ħin, immaniġġata mir-runtime ta' Go. Tħallaqha hija sempliċi — poġġi biss `go` qabel it-taħdita ta' funzjoni. Goroutines hija l-karattiristika ta' concurrency li tiddefinixxi lil Go — ħafna irħas mill-OS threads, għalhekk tista' taħdem eluf jew miljuni.

## Tħallaq 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")
}()
```

Il-kelma prinċipali `go` tibda l-funzjoni fuq goroutine ġdid u tirritorna minnufih — il-kodiċi li sejjaħ ikompli mingħajr ma ntella'.

## Għaliex goroutines speċjali: huma irħas

```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 mhumiex OS threads — l-iskeduler ta' Go jesfokus ħafna goroutines fuq ftit OS threads. Dan jagħmelhom straordinarilijnt irħas, billi jippermettu concurrency massive (eż. goroutine wieħed għal kull konessjoni fi server li jużża miljuni ta' konessjonijiet).

## Il-problema tas-sinkronizzazzjoni: main tista' toħroġ kmieni wisq

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

Meta `main` jirritorna, il-programm jispiċċa — jaqtol xi goroutines li għadhom iduru. Għandek bżonn tikkoordina.

## Stennija ma' 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` hija l-mod standard għall-istennija li sett ta' goroutines jispiċċa.

## Komunikazzjoni permezz ta' channels

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

Il-filosofija ta' Go: **"Tgħix tikkonkomunika billi taqsam il-memorja; aqsam il-memorja billi tikkonkomunika"** — uża channels biex tgħaddi d-data bejn goroutines minflok varjabbli maqsuma + locks.

## Għaliex dan importanti

Goroutines hija l-karattiristika li tiddefinixxi lil Go u l-raguni ewlenija għaliex Go tkun eċċellenti f'sistemi concurrent u netwark.

Il-ħafifija estrema tagħhom (kilobytes vs megabytes għal threads, iskeduljati M:N fuq OS threads) jagħmlu concurrency massive prattiku u faċli — server tista' tawwela goroutine għal kull talba jew konessjoni mingħajr concerns dwar ir-risorsi, li huwa diffiċli jew impossibbli ma' OS threads.

Il-fehim kif tawwelhom (`go`), il-bżonn kritiku **biex tisinkronizza** (main li toħroġ taqtol goroutines; uża `WaitGroup` biex tistenna), u l-preferenza ta' Go għal **komunikazzjoni permezz ta' channels** minflok il-memorja maqsuma hija fundamentali biex tikteb Go concurrent korrett.

Goroutines (u l-patterns madwarhom) huma ċentrali għall-proposta tal-valur ta' Go u fost it-topiċi l-aktar importanti u l-aktar testjati fil-lingwa.