Τι προκαλεί διαρροές goroutine και πώς τις αποτρέπετε;

Question

Accepted Answer

Μια **διαρροή goroutine** είναι ένα goroutine που δεν τερματίζεται ποτέ — παραμένει κλειδωμένο ή τρέχει για πάντα, καταναλώνοντας μνήμη (και διατηρώντας τα αντικείμενα που αναφέρει ζωντανά) για όλη τη διάρκεια του προγράμματος. Επειδή τα goroutine είναι φθηνά για εκκίνηση, είναι εύκολο να τα χάσετε, και οι διαρροές συσσωρεύονται σιωπηλά μέχρι η υπηρεσία να υποβαθμιστεί ή να εξαντληθεί η μνήμη.

## Αιτία 1: κλειδωμένο σε ένα κανάλι χωρίς αποστολέα/δέκτη

```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 κλειδωμένο σε αποστολή/λήψη καναλιού που δεν ολοκληρώνεται ποτέ θα περιμένει **για πάντα** — δεν καταστρέφεται ποτέ από τον garbage collector επειδή τεχνικά εξακολουθεί να «τρέχει».

## Αιτία 2: χωρίς ακύρωση / σήμα ολοκλήρωσης

```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
}
```

## Πρόληψη 1: χρήση context για ακύρωση

```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()
```

Δίνοντας σε κάθε goroutine μακράς διάρκειας τη δυνατότητα να ακυρωθεί (`<-ctx.Done()`) είναι η κύρια άμυνα — διασφαλίζει ότι τα goroutine τερματίζονται όταν η εργασία τους δεν είναι πλέον απαραίτητη.

## Πρόληψη 2: χρήση buffer κανάλια ή διασφάλιση δεκτών

```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
```

## Πρόληψη 3: πάντα κλείστε τα κανάλια / αποστραγγίστε τα σωστά

```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) }
}()
```

## Ανίχνευση διαρροών

```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
```

Η παρακολούθηση `runtime.NumGoroutine()` (ένας ολοένα αυξανόμενος αριθμός σηματοδοτεί μια διαρροή), η επιθεώρηση goroutine dumps μέσω `pprof`, και η χρήση `goleak` στις δοκιμές είναι τα κύρια εργαλεία ανίχνευσης.

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

Οι διαρροές goroutine είναι ένα από τα πιο συνηθισμένα και δύσκολα προβλήματα στις υπηρεσίες Go παραγωγής.

Επειδή τα goroutine είναι τόσο φθηνά για εκκίνηση, οι προγραμματιστές τα δημιουργούν ελεύθερα — αλλά ένα goroutine κλειδωμένο για πάντα (σε ένα κανάλι χωρίς ομόλογο, ή σε ένα άπειρο βρόχο χωρίς ακύρωση) **δεν τερματίζεται ποτέ και δεν απελευθερώνει τη μνήμη του** (συμπεριλαμβανομένου όλα όσα αναφέρει).

Σε ένα μακροχρόνιο διακομιστή, αυτές οι διαρροές συσσωρεύονται σιωπηλά, καταναλώνοντας βαθμιαία τη μνήμη μέχρι η υπηρεσία να υποβαθμιστεί ή να καταρρεύσει — και είναι δύσκολο να εντοπιστούν επειδή δεν υπάρχει άμεσο σφάλμα.

Η κατανόηση των αιτιών (κλειδωμένες λειτουργίες καναλιού, αγνοούμενη ακύρωση) και της πρόληψης (**ακύρωση βασισμένη σε context** ως κύρια άμυνα, σωστό κλείσιμο καναλιού, buffer κανάλια, διασφάλιση δεκτών) είναι απαραίτητη για τη συγγραφή αξιόπιστου συντρέχοντος Go.

Η γνώση των εργαλείων ανίχνευσης (`runtime.NumGoroutine`, pprof, goleak) είναι εξίσου σημαντική.

Αυτό είναι ένα κριτικό, συχνά δοκιμασμένο θέμα που διαχωρίζει τους προγραμματιστές που μπορούν να γράψουν συντρέχον Go ετοιμοπαράδοτου επιπέδου από εκείνους που γράφουν κώδικα που δημιουργεί διαρροές υπό συνεχή φόρτο.