Ποια είναι τα κοινά πρότυπα concurrent (παράλληλης εκτέλεσης) στο Go;

Question

Accepted Answer

Οι goroutines και τα channels του Go επιτρέπουν ένα σύνολο καθιερωμένων **προτύπων concurrent**, τα οποία επιλύουν κοινά προβλήματα — διανομή εργασίας, fan-out/in, pipelines και rate limiting. Η γνώση αυτών των ιδιωματικών προτύπων σας επιτρέπει να φτιάξετε σωστά και αποδοτικά concurrent συστήματα.

## Worker pool — περιορισμένη concurrent εκτέλεση

```go
func workerPool(jobs <-chan int, results chan<- int, numWorkers int) {
    var wg sync.WaitGroup
    for w := 0; w < numWorkers; w++ {     // a FIXED number of workers
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {        // each worker pulls jobs until the channel closes
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}
```

Ενα **worker pool** εκτελεί έναν σταθερό αριθμό goroutines που καταναλώνουν από ένα κοινό κανάλι εργασιών — περιορίζοντας την concurrent εκτέλεση (π.χ. μην ανοίξετε 10.000 συνδέσεις DB· χρησιμοποιήστε 10 workers). Αυτό είναι το πιο σημαντικό πρότυπο για τον έλεγχο της χρήσης πόρων.

## Fan-out / fan-in

```text
Fan-out: distribute work across MULTIPLE goroutines (parallelize)
Fan-in:  MERGE results from multiple goroutines back into one channel
```

```go
// fan-in: merge several channels into one
func merge(channels ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c { out <- v }   // forward each channel's values to out
        }(ch)
    }
    go func() { wg.Wait(); close(out) }()    // close out when all sources are drained
    return out
}
```

## Pipeline — στάδια συνδεδεμένα μέσω channels

```go
// each stage is a goroutine: receives from an input channel, sends to an output channel
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { for _, n := range nums { out <- n }; close(out) }()
    return out
}
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { for n := range in { out <- n * n }; close(out) }()
    return out
}
// compose: square(generate(1,2,3)) → a streaming pipeline
for result := range square(generate(1, 2, 3)) { fmt.Println(result) }
```

Ενα **pipeline** συνδέει στάδια επεξεργασίας μέσω channels — τα δεδομένα ρέουν, και κάθε στάδιο τα μετασχηματίζει concurrently.

## Rate limiting

```go
limiter := time.Tick(200 * time.Millisecond)   // a tick every 200ms
for req := range requests {
    <-limiter                                    // wait for the next tick before proceeding
    go handle(req)                                // → at most 5 requests/second
}
```

## Ακύρωση με context (διατομικό)

```go
select {
case result := <-work:
case <-ctx.Done():    return   // stop on cancellation — prevents leaks
}
```

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

Αυτά τα πρότυπα concurrent είναι το πρακτικό εργαλειοθήκη για την κατασκευή πραγματικών concurrent συστημάτων Go, μετατρέποντας raw goroutines και channels σε δομημένες, σωστές λύσεις για επαναλαμβανόμενα προβλήματα.

Το **worker pool** είναι ιδιαίτερα σημαντικό — περιορίζει την concurrent εκτέλεση για την προστασία περιορισμένων πόρων (συνδέσεις βάσης δεδομένων, όρια ρυθμού API, μνήμη), αποτρέποντας το συνηθισμένο λάθος της εκκίνησης απεριόριστων goroutines που εξαντλούν το σύστημα. Το **fan-out/fan-in** παραλληλοποιεί την εργασία και συγχωνεύει τα αποτελέσματα· τα **pipelines** μοντελοποιούν καθαρά τους μετασχηματισμούς δεδομένων ροής· το **rate limiting** ελέγχει την ρυθμαπόδοση.

Σε συνδυασμό με την **ακύρωση βάσει context** (για αποφυγή διαρροών goroutines), αυτά τα πρότυπα είναι ο τρόπος με τον οποίο οι production Go υπηρεσίες χειρίζονται την concurrent εκτέλεση με ασφάλεια και αποδοτικότητα.

Η κατανόησή τους — και ειδικά η γνώση του περιορισμού της concurrent εκτέλεσης με worker pools αντί της εκκίνησης απεριόριστων goroutines — είναι ένα σημάδι senior Go ικανότητας και ένα συχνό προχωρημένο θέμα συνέντευξης, καθώς η αφελής concurrent εκτέλεση (απεριόριστες goroutines, διαρροές, races) είναι μια συνηθισμένη πηγή σφαλμάτων production.