What is context.AfterFunc in Go?

Question

Accepted Answer

context.AfterFunc is a function for **registering callback functions** that execute when the context finishes.

```go
import "context"

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

// Register callback
    stop := context.AfterFunc(ctx, func() {
        fmt.Println("Context cancelled, cleaning up...")
        cleanupResources()
    })

// Start work
    go doWork(ctx)

// Stop after 5 seconds
    time.Sleep(5 * time.Second)
    cancel()  // Will trigger callback!

// stop() — cancels callback registration
    // if context hasn't finished yet
}

// Example: timeout with cleanup
func processWithTimeout(ctx context.Context) error {
    ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
    defer cancel()

// Cleanup on cancellation
    stop := context.AfterFunc(ctx, func() {
        log.Println("Request cancelled, releasing resources")
        releaseLock()
    })
    defer stop()  // Cancel callback if everything is fine

return doWork(ctx)
}

// Example: goroutine pool
func startPool(ctx context.Context, workers int) {
    context.AfterFunc(ctx, func() {
        fmt.Println("Stopping all workers...")
        // Stopping workers
    })

for i := 0; i < workers; i++ {
        go worker(ctx)
    }
}
```

**When to use:**
- Resource cleanup on cancellation.
- Completion logging.
- Metrics (tracking cancelled requests).

Go: What is context.AfterFunc in Go?