type emptyCtx int

func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
    return
}

func (*emptyCtx) Done() <-chan struct{} {
    return nil
}

func (*emptyCtx) Err() error {
    return nil
}

func (*emptyCtx) Value(key any) any {
    return nil
}

var (
        background = new(emptyCtx)
        todo       = new(emptyCtx)
)
func Background() Context {
        return background
}
func TODO() Context {
        return todo
}

package main

import (
    "context"
    "fmt"
)

func step1(ctx context.Context) context.Context {
    //根據(jù)父context創(chuàng)建子context，創(chuàng)建context時允許設(shè)置一個<key,value>對，key和value可以是任意數(shù)據(jù)類型
    child := context.WithValue(ctx, "name", "大臉貓")
    return child
}

func step2(ctx context.Context) context.Context {
    fmt.Printf("name %s\n", ctx.Value("name"))
    //子context繼承了父context里的所有key value
    child := context.WithValue(ctx, "age", 18)
    return child
}

func step3(ctx context.Context) {
    fmt.Printf("name %s\n", ctx.Value("name")) //取出key對應(yīng)的value
    fmt.Printf("age %d\n", ctx.Value("age"))
}

func main1() {
    grandpa := context.Background() //空context
    father := step1(grandpa)        //father里有一對<key,value>
    grandson := step2(father)       //grandson里有兩對<key,value>
    step3(grandson)
}

func f1() {
    ctx, cancel := context.WithCancel(context.Background())
    go func() {
        time.Sleep(100 * time.Millisecond)
        cancel() //調(diào)用cancel，觸發(fā)Done
    }()
    select {
    case <-time.After(300 * time.Millisecond):
        fmt.Println("未超時")
    case <-ctx.Done(): //ctx.Done()是一個管道，調(diào)用了cancel()都會關(guān)閉這個管道，然后讀操作就會立即返回
        err := ctx.Err()        //如果發(fā)生Done（管道被關(guān)閉），Err返回Done的原因，可能是被Cancel了，也可能是超時了
        fmt.Println("超時:", err) //context canceled
    }
}

func f2() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100) //超時后會自動調(diào)用context的Deadline，Deadline會，觸發(fā)Done
    defer cancel()
    select {
    case <-time.After(300 * time.Millisecond):
        fmt.Println("未超時")
    case <-ctx.Done(): //ctx.Done()是一個管道，context超時或者調(diào)用了cancel()都會關(guān)閉這個管道，然后讀操作就會立即返回
        err := ctx.Err()        //如果發(fā)生Done（管道被關(guān)閉），Err返回Done的原因，可能是被Cancel了，也可能是超時了
        fmt.Println("超時:", err) //context deadline exceeded
    }
}

func inherit_timeout() {
    parent, cancel1 := context.WithTimeout(context.Background(), time.Millisecond*1000) //parent設(shè)置100ms超時
    t0 := time.Now()
    defer cancel1()

    time.Sleep(500 * time.Millisecond) //消耗掉500ms

    // child, cancel2 := context.WithTimeout(parent, time.Millisecond*1000) //parent還剩500ms，child設(shè)置了1000ms之后到期，child.Done()管道的關(guān)閉時刻以較早的為準(zhǔn)，即500ms后到期
    child, cancel2 := context.WithTimeout(parent, time.Millisecond*100) //parent還剩500ms，child設(shè)置了100ms之后到期，child.Done()管道的關(guān)閉時刻以較早的為準(zhǔn)，即100ms后到期
    t1 := time.Now()
    defer cancel2()

    select {
    case <-child.Done():
        t2 := time.Now()
        fmt.Println(t2.Sub(t0).Milliseconds(), t2.Sub(t1).Milliseconds())
        fmt.Println(child.Err()) //context deadline exceeded
    }
}

package main
import (
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

func main() {
    client := http.Client{
        Timeout: 2 * time.Second, //小于10秒，導(dǎo)致請求超時，會觸發(fā)Server端的http.Request.Context的Done
    }
    if resp, err := client.Get("http://127.0.0.1:5678/"); err == nil {
        defer resp.Body.Close()
        fmt.Println(resp.StatusCode)
        if bs, err := ioutil.ReadAll(resp.Body); err == nil {
            fmt.Println(string(bs))
        }
    } else {
        fmt.Println(err) //Get "http://127.0.0.1:5678/": context deadline exceeded (Client.Timeout exceeded while awaiting headers)
    }
}

package main
import (
    "fmt"
    "net/http"
    "time"
)

func welcome(w http.ResponseWriter, req *http.Request) {
    ctx := req.Context() //取得request的context
    select {
    case <-time.After(10 * time.Second): //故意慢一點，10秒后才返回結(jié)果
        fmt.Fprintf(w, "welcome")
    case <-ctx.Done(): //超時后client會撤銷請求，觸發(fā)ctx.cancel()，從而關(guān)閉Done()管道
        err := ctx.Err()            //如果發(fā)生Done（管道被關(guān)閉），Err返回Done的原因，可能是被Cancel了，也可能是超時了
        fmt.Println("server:", err) //context canceled
    }
}

func main() {
    http.HandleFunc("/", welcome)
    http.ListenAndServe(":5678", nil)
}