Για τι χρησιμοποιείται το πακέτο context;

Question

Accepted Answer

Το πακέτο **`context`** μεταφέρει **σήματα ακύρωσης, χρονικά όρια και τιμές με εμβέλεια αιτήματος** σε όλα τα όρια API και goroutines. Είναι ο τυπικός μηχανισμός για τον έλεγχο της διάρκειας ζωής των λειτουργιών — ειδικά για την ακύρωση της εργασίας και τη διάδοση χρονικών ορίων μέσα από μια σειρά κλήσεων συναρτήσεων.

## Το βασικό πρόβλημα που λύνει

```text
A request starts work across many goroutines/functions (DB query, API call, etc.).
If the client disconnects or a timeout hits, you want to CANCEL all that work
so goroutines don't keep running uselessly (wasting resources / leaking).
→ context propagates the "stop now" signal down the entire call chain.
```

## Δημιουργία περιεχομένων

```go
ctx := context.Background()          // the root context (top of the tree)
ctx := context.TODO()                 // placeholder when unsure

// with a timeout — auto-cancels after the duration
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()                        // ALWAYS call cancel to release resources

// with manual cancellation
ctx, cancel := context.WithCancel(context.Background())
// call cancel() to signal cancellation

// with a deadline (specific time)
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Minute))
```

`WithTimeout`/`WithDeadline`/`WithCancel` αποκτούν ένα context παιδιού που μπορεί να ακυρωθεί· πρέπει να `defer cancel()` για να ελευθερώσετε τους πόρους του.

## Ανταπόκριση στην ακύρωση

```go
func doWork(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():            // fires when cancelled or timed out
            return ctx.Err()           // returns context.Canceled or DeadlineExceeded
        case work := <-jobs:
            process(work)
        }
    }
}
```

Οι συναρτήσεις ελέγχουν `ctx.Done()` (ένα κανάλι που κλείνει κατά την ακύρωση) και σταματούν αμέσως — έτσι η ακύρωση διαδίδεται στην πραγματικότητα.

## Διάδοση context μέσω μιας αλυσίδας κλήσεων (η σύμβαση)

```go
// ctx is conventionally the FIRST parameter, named ctx
func handler(ctx context.Context, ...) {
    data, err := fetchFromDB(ctx, id)   // pass it down — DB call honors cancellation
}
func fetchFromDB(ctx context.Context, id int) (...) {
    row := db.QueryRowContext(ctx, ...)  // standard-library APIs accept context
}
```

Το context ρέει προς τα κάτω στη στοίβα κλήσεων ως πρώτη παράμετρος, έτσι ώστε η ακύρωση να φτάσει σε κάθε επίπεδο (συμπεριλαμβανομένων των κλήσεων DB/HTTP της τυπικής βιβλιοθήκης που δέχονται context).

## Τιμές με εμβέλεια αιτήματος (χρησιμοποιήστε με φειδώ)

```go
ctx = context.WithValue(ctx, requestIDKey, "abc-123")   // attach a value
id := ctx.Value(requestIDKey)                            // retrieve it downstream
// ⚠️ for request-scoped metadata (request IDs, auth) — NOT for passing regular params
```

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

Το πακέτο `context` είναι θεμελιώδες για τη σύνταξη ισχυρών Go services σε επίπεδο παραγωγής — είναι ο τυπικός, ιδιωματικός τρόπος διαχείρισης **ακύρωσης και χρονικών ορίων** σε όλα τα goroutines και τα όρια API.

Η κύρια αξία του είναι η πρόληψη της σπατάλης εργασίας και διαρροών πόρων: όταν ένας πελάτης αποσυνδέεται, ένα χρονικό όριο περνά ή ένα διακομιστή κλείνει, το context διαδίδει το σήμα ακύρωσης έτσι ώστε όλα τα goroutines και οι λειτουργίες που δημιουργήθηκαν για αυτό το αίτημα σταματούν αμέσως αντί να τρέχουν άσκοπα (κύρια άμυνα κατά των διαρροών goroutine).

Είναι διαδεδομένη στο πραγματικό Go — HTTP servers, κλήσεις βάσης δεδομένων, gRPC και οι περισσότερες βιβλιοθήκες δικτύου δέχονται `context.Context` ως πρώτη παράμετρο.

Η κατανόηση του τρόπου δημιουργίας περιεχομένων (`WithTimeout`/`WithCancel`), ανταπόκρισης στην ακύρωση (`<-ctx.Done()`), του κανόνα must-call-`cancel()` και της σύμβασης threading context μέσω αλυσίδων κλήσεων είναι απαραίτητη για οποιοδήποτε σοβαρό Go backend work και ένα κοινό θέμα συνέντευξης.