func main() {
  // Create an HTTP server that listens on port 8000
 http.ListenAndServe(":8000", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 ctx := r.Context()
 // This prints to STDOUT to show that processing has started
 fmt.Fprint(os.Stdout, "processing request\n")
 // We use `select` to execute a peice of code depending on which
 // channel receives a message first
 select {
   case -time.After(2 * time.Second):
 // If we receive a message after 2 seconds
 // that means the request has been processed
 // We then write this as the response
 w.Write([]byte("request processed"))
   case -ctx.Done():
 // If the request gets cancelled, log it
 // to STDERR
 fmt.Fprint(os.Stderr, "request cancelled\n")
 }
 }))
}

func operation1(ctx context.Context) error {
 // Let's assume that this operation failed for some reason
 // We use time.Sleep to simulate a resource intensive operation
 time.Sleep(100 * time.Millisecond)
 return errors.New("failed")
}

func operation2(ctx context.Context) {
 // We use a similar pattern to the HTTP server
 // that we saw in the earlier example
 select {
  case -time.After(500 * time.Millisecond):
 fmt.Println("done")
  case -ctx.Done():
 fmt.Println("halted operation2")
 }
}

func main() {
 // Create a new context
 ctx := context.Background()

 // Create a new context, with its cancellation function
 // from the original context
 ctx, cancel := context.WithCancel(ctx)

 // Run two operations: one in a different go routine
 go func() {
 err := operation1(ctx)
 // If this operation returns an error
 // cancel all operations using this context
 if err != nil {
 cancel()
 }
 }()
 // Run operation2 with the same context we use for operation1
 operation2(ctx)
}

// The context will be cancelled after 3 seconds
// If it needs to be cancelled earlier, the `cancel` function can
// be used, like before

ctx, cancel := context.WithTimeout(ctx, 3*time.Second)

// The context will be cancelled on 2009-11-10 23:00:00
ctx, cancel := context.WithDeadline(ctx, time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC))

func main() {
 // Create a new context
 // With a deadline of 100 milliseconds
 ctx := context.Background()
 ctx, _ = context.WithTimeout(ctx, 100*time.Millisecond)
 // Make a request, that will call the google homepage
 req, _ := http.NewRequest(http.MethodGet, "http://google.com", nil)
 // Associate the cancellable context we just created to the request
 req = req.WithContext(ctx)

 // Create a new HTTP client and execute the request
 client := http.Client{}
 res, err := client.Do(req)

 // If the request failed, log to STDOUT
 if err != nil {
 fmt.Println("Request failed:", err)
 return
 }

 // Print the statuscode if the request succeeds
 fmt.Println("Response received, status code:", res.StatusCode)
}

Response received, status code: 200

Request failed: Get http://google.com: context deadline exceeded