Go Channel Patterns - Cancellation

package main

import (
    "context"
    "fmt"
    "math/rand"
    "time"
)

func main() {
    // a duration that sets the max time to perform the operation

    // e.g 150 ms to get the ice cream cone
    duration := 1 * time.Millisecond

    // context.Background() returns a non-nil, empty Context.
    // It is never canceled, has no values, and has no deadline.
    // It is typically used by the main function, initialization, and tests,
    // and as the top-level Context for incoming requests.
    emptyCtx := context.Background()

    // Create new context from emptyCtx + add timeout of 150 ms
    // ctx is new context with timeout
    // cancel is a function that releases resources associated with context

    // e.g. ticker that the manager uses to check if he gets the ice cream cone fast enough
    ctx, cancel := context.WithTimeout(emptyCtx, duration)

    // Canceling this context releases resources associated with it,
    // so code should call cancel as soon as the operations running in
    // this Context complete

    // e.g. command manager uses to cancel the context (unit of work - getting ice cream cone)
    defer cancel()

    // IMPORTANT:
    // Make buffered channel of size 1, and type string which provides signaling semantics.
    // Buffered channel ensures that the worker goroutine can perform the send operation
    // and complete even if there is no-one on the receive side.
    // e.g.
    // - if worker goroutine does NOT finish in 150ms
    // -- main goroutine will continue
    // -- this will cause worker goroutine leak
    //    since there is no-one goroutine to receive the sent signal (so it blocks and waits)

    // e.g. used to prevent employee from being blocked if he doesn't complete the work in 150ms
    ch := make(chan string, 1)

    // create worker goroutine
    go func() {
        // Simulate the idea of unknown latency (do not use in production).
        // Don't forget that context timeout is 150 ms, but this can take up to 200 ms.

        // e.g. employee reaches out for the ice cream cone from the box
        time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)

        // send signal when work is done
        // e.g. employee passes ice creeam cone to the managers' hand
        ch <- "paper"
    }()

    // select-case allow us to perform multiple channel operations
    // at the same time, on the same goroutine

    // e.g. manager waits for ice cream cone, or for 150 ms timer to time out
    select {

    // best case scenario:
    // receive a result from worker goroutine in under the 150 ms

    // e.g. employee finds and passes the ice cream cone to the manager
    case d := <-ch:
        fmt.Println("work complete", d)

    // ctx.Done() call starts the 150ms duration clock ticking.
    // If 150 ms passes before the worker goroutine finishes, this println will be executed

    // e.g. manager doesn't wait for employee to get the ice cream cone anymore
    case <-ctx.Done():
        fmt.Println("work cancelled")
    }
}

go run main.go

work complete paper

go run main.go

work cancelled