Çfarë janë goroutines?

Question

Accepted Answer

Një **goroutine** është një funksion i lehtë, që ekzekutohet njëkohësisht dhe menaxhohet nga runtime-i i Go-s. Nisja e një goroutine është aq e thjeshtë sa të vendosësh `go` para një thirrjeje funksioni. Goroutines janë karakteristika e nënshkrimit të concurrency në Go — shumë më lira se threadshet e OS-it, kështu që mund të ekzekutosh mijëra ose miliona.

## Nisja e një 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")
}()
```

Fjalëkyçi `go` fillon funksionin në një goroutine të re dhe kthehet menjëherë — kodi i thirrëses vazhdon pa pritur.

## Pse goroutines janë të veçantë: ato janë lira

```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 nuk janë threadshet e OS-it — scheduler-i i Go-s multiplekson shumë goroutines në disa threadshe OS-i. Kjo i bën ato jashtëzakonisht lira, duke mundësuar concurrency masiv (p.sh. një goroutine për lidhje në një server që përpunon miliona lidhje).

## Problemi i sinkronizimit: main mund të dalë shumë shpejt

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

Kur `main` kthehet, programi përfundon — duke vrarë çdo goroutine që ende është duke ekzekutuar. Duhet të koordinosh.

## Pritja me 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` është mënyra standarde për të pritur që një grup goroutines të përfundojnë.

## Komunikimi me channels

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

Filozofia e Go-s: **"Mos komuniko duke ndarë memorien; shpenzo memorien duke komunikuar"** — përdor channels për të kaluar të dhëna ndërmjet goroutines në vend të variablave të ndarë + locks.

## Pse ka rëndësi

Goroutines janë karakteristika përkufizuese e Go-s dhe arsyja kryesore pse ai bën një punë të shkëlqyeshme në sistemet e njëkohshme, të rrjetuara.

Lehtsira e tyre ekstreme (kilobajt kundrejt megabajt për threadshet, të planifikuara M:N në threadshet OS-i) i bën concurrency masiv praktik dhe të lehtë — një server mund të nise një goroutine për kërkesë ose lidhje pa shqetésime të burimeve, gjë që është e vështirë ose e pamundur me threadshet OS-i.

Kuptimi se si t'i nisësh ato (`go`), nevojën kritike për **sinkronizim** (main që del vret goroutines; përdor `WaitGroup` për të pritur), dhe preferencën e Go-s për **komunikimin përmes channels** në vend të memories së ndarë është themeltar për shkrimin e Go-s të saktë me concurrency.

Goroutines (dhe modelet rreth tyre) janë qendër në propozimin e vlerës së Go-s dhe midis temave më të rëndësishme dhe më të testuara shpesh në gjuhën.