Контекст: отмена операций

select {
case <-ctx.Done(): 
   fmt.Println("Контекст отменён, следовательно, канал, " + 
               "возвращаемый из Done(), закрыт")
case x: <-ch1:
   fmt.Println("Канал ch1 закрыт или в него записано значение, " + 
               "прочитанное значение:", x)
case <-ch2:
   fmt.Println("Канал ch2 закрыт или в него записано значение, " + 
               "само значение игнорируется")
default:
   fmt.Println("Ни одно из событий не произошло")
} 

package main

import (
    "context"
    "fmt"
    "time"
)

func doSomething(ctx context.Context) {
    fmt.Println("Начало работы")
    for i := 0; i < 5; i++ {
        select {
        case <-ctx.Done():
            fmt.Println("Прервали работу")
            return
        default:
            fmt.Println(i)
            time.Sleep(1 * time.Second)
        }
    }
    fmt.Println("Конец работы")
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    // через 1,5 секунды вызываем cancel для отмены операции
    // если cancel вызовется два раза, это не приведёт к ошибке
    time.AfterFunc(1500*time.Millisecond, cancel)
     
    doSomething(ctx)
} 

func doSomething(ctx context.Context) {
    fmt.Println("Начало работы")
    for i := 0; i < 5; i++ {
        if ctx.Err() != nil {
            fmt.Println("Прервали работу")
            return
        }
        fmt.Println(i)
        time.Sleep(1 * time.Second)
    }
    fmt.Println("Конец работы")
} 

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
// эквивалентно
ctx, cancel := context.WithDeadline(context.Background(), 
                                    time.Now().Add(2*time.Second)) 

Cause(c Context) error
WithCancelCause(parent Context) (ctx Context, cancel CancelCauseFunc) 

package main

import (
    "context"
    "fmt"
    "time"
)

func doSomething(ctx context.Context) {
    fmt.Println("Начало работы")
    for i := 0; i < 5; i++ {
        select {
        case <-ctx.Done():
            return
        default:
            fmt.Println(i)
            time.Sleep(1 * time.Second)
        }
    }
    fmt.Println("Конец работы")
}

func main() {
    // если указать интервал 1500 миллисекунд, то doSomething
    // успеет выполниться полностью
    ctx, cancel := context.WithTimeout(context.Background(), 1500*time.Millisecond)
    defer cancel()
    doSomething(ctx)

    // проверяем, как завершился контекст
    switch ctx.Err() {
    case context.Canceled:
        fmt.Println("Прервали работу")
    case context.DeadlineExceeded:
        fmt.Println("Истекло время работы")
    }
} 

package main

import (
    "context"
    "fmt"
)

func doValue(ctx context.Context) {
    fmt.Println(ctx.Value("group"), ctx.Value("name"))
}

func main() {
    ctx := context.WithValue(context.Background(), "group", "admin")
    ctxuser := context.WithValue(ctx, "name", "Dima")

    doValue(ctxuser)
} 

// NewRequestWithContext создаёт запрос с контекстом
func NewRequestWithContext(ctx context.Context, method, url string, 
                           body io.Reader) (*Request, error)
// WithContext устанавливает контекст для запроса
func (r *Request) WithContext(ctx context.Context) *Request
// Context возвращает контекст запроса
func (r *Request) Context() context.Context 

package main

import (
    "context"
    "io"
    "log"
    "net/http"
    "time"
)

func main() {
    // создаём контекст с максимальным временем запроса
    ctx, cancel := context.WithTimeout(context.Background(), 
                         time.Duration(time.Millisecond*500))
    defer cancel()
    // создаём запрос к серверу http://httpbin.org, ответ будет возвращаться
    // с задержкой в одну секунду, которая указана в запросе /delay/1
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, 
                                "http://httpbin.org/delay/1", nil)
    // эквивалентно
    // req, err := http.NewRequest(http.MethodGet, 
    //                          "http://httpbin.org/delay/1", nil)
    // ...
    // req.WithContext(ctx)
    if err != nil {
        log.Fatal(err)
    }
    c := &http.Client{}
    res, err := c.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer res.Body.Close()
    out, err := io.ReadAll(res.Body)
    if err != nil {
        log.Fatal(err)
    }
    log.Println(string(out))
}