Τι είναι 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` keyword ξεκινά τη συνάρτηση σε ένα νέο 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 multiplexes πολλά goroutines σε λίγα OS threads. Αυτό τα κάνει εξαιρετικά φθηνά, ενεργοποιώντας μαζική concurrency (π.χ. ένα goroutine ανά σύνδεση σε ένα server που χειρίζεται εκατομμύρια συνδέσεις).

## Το πρόβλημα του συγχρονισμού: το 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: **"Μην επικοινωνείτε μοιράζοντας μνήμη· μοιράστε μνήμη επικοινωνώντας"** — χρησιμοποιήστε channels για να μεταφέρετε δεδομένα μεταξύ goroutines αντί για κοινές μεταβλητές + κλειδώματα.

## Γιατί έχει σημασία

Τα goroutines είναι το χαρακτηριστικό που ορίζει το Go και ο κύριος λόγος που διαπρέπει στα ταυτόχρονα, δικτυακά συστήματα.

Η εξαιρετική τους ελαφρότητα (kilobytes έναντι megabytes για threads, προγραμματισμένα M:N σε OS threads) κάνει τη μαζική concurrency πρακτική και εύκολη — ένα server μπορεί να δημιουργήσει ένα goroutine ανά αίτημα ή σύνδεση χωρίς ανησυχίες σχετικά με πόρους, κάτι που είναι δύσκολο ή αδύνατο με OS threads.

Η κατανόηση του τρόπου εκκίνησής τους (`go`), της κρίσιμης ανάγκης για **συγχρονισμό** (το main που εξέρχεται σκοτώνει goroutines· χρησιμοποιήστε `WaitGroup` για να περιμένετε), και της προτίμησης του Go για **επικοινωνία μέσω channels** έναντι της κοινής μνήμης είναι θεμελιώδη για τη σωστή σύγχρονη προγραμματισμό σε Go.

Τα goroutines (και τα πρότυπα γύρω τους) είναι κεντρικά στην πρόταση αξίας του Go και ανάμεσα στα πιο σημαντικά και συχνά δοκιμαζόμενα θέματα της γλώσσας.