golang context用法详解

背景

在go服务器中，对于每个请求的request都是在单独的goroutine中进行的，处理一个request也可能设计多个goroutine之间的交互，使用context可以使开发者方便的在这些goroutine里传递request相关的数据、取消goroutine的signal或截止日期。

Context结构

// A Context carries a deadline, cancelation signal, and request-scoped values

// across API boundaries. Its methods are safe for simultaneous use by multiple

// goroutines.

type Context interface {

    // Done returns a channel that is closed when this Context is canceled

    // or times out.

    Done() <-chan struct{}

    // Err indicates why this context was canceled, after the Done channel

    // is closed.

    Err() error

    // Deadline returns the time when this Context will be canceled, if any.

    Deadline() (deadline time.Time, ok bool)

    // Value returns the value associated with key or nil if none.

    Value(key interface{}) interface{}

}

Done 方法在Context被取消或超时时返回一个close的channel,close的channel可以作为广播通知，告诉给context相关的函数要停止当前工作然后返回。

当一个父operation启动一个goroutine用于子operation，这些子operation不能够取消父operation。下面描述的WithCancel函数提供一种方式可以取消新创建的Context.

Context可以安全的被多个goroutine使用。开发者可以把一个Context传递给任意多个goroutine然后cancel这个context的时候就能够通知到所有的goroutine。

Err方法返回context为什么被取消。

Deadline返回context何时会超时。

Value返回context相关的数据。

继承的Context

BackGround

// Background returns an empty Context. It is never canceled, has no deadline,

// and has no values. Background is typically used in main, init, and tests,

// and as the top-level Context for incoming requests.

func Background() Context

BackGound是所有Context的root，不能够被cancel。

WithCancel

WithCancel返回一个继承的Context,这个Context在父Context的Done被关闭时关闭自己的Done通道，或者在自己被Cancel的时候关闭自己的Done。
WithCancel同时还返回一个取消函数cancel，这个cancel用于取消当前的Context。

package main

import (

    "context"

    "log"

    "os"

    "time"

)

var logg *log.Logger

func someHandler() {

    ctx, cancel := context.WithCancel(context.Background())

    go doStuff(ctx)

//10秒后取消doStuff

    time.Sleep( * time.Second)

    cancel()

}

//每1秒work一下，同时会判断ctx是否被取消了，如果是就退出

func doStuff(ctx context.Context) {

    for {

        time.Sleep( * time.Second)

        select {

        case <-ctx.Done():

            logg.Printf("done")

            return

        default:

            logg.Printf("work")

        }

    }

}

func main() {

    logg = log.New(os.Stdout, "", log.Ltime)

    someHandler()

    logg.Printf("down")

}

E:\wdy\goproject>go run context_learn.go

:: work

:: work

:: work

:: work

:: work

:: work

:: work

:: work

:: work

:: down

withDeadline withTimeout

WithTimeout func(parent Context, timeout time.Duration) (Context, CancelFunc)

WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).

WithTimeout 等价于 WithDeadline(parent, time.Now().Add(timeout)).

对上面的样例代码进行修改

func timeoutHandler() {

    // ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)

    ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(*time.Second))

    // go doTimeOutStuff(ctx)

    go doStuff(ctx)

    time.Sleep( * time.Second)

    cancel()

}

func main() {

    logg = log.New(os.Stdout, "", log.Ltime)

    timeoutHandler()

    logg.Printf("end")

}

:: work

:: work

:: work

:: work

:: done

:: end

可以看到doStuff在context超时的时候被取消了，ctx.Done()被关闭。
将context.WithDeadline替换为context.WithTimeout

func timeoutHandler() {

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

    // ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(5*time.Second))

    // go doTimeOutStuff(ctx)

    go doStuff(ctx)

    time.Sleep( * time.Second)

    cancel()

}

:: work

:: work

:: work

:: work

:: done

:: end

doTimeOutStuff替换doStuff

func doTimeOutStuff(ctx context.Context) {

    for {

        time.Sleep( * time.Second)

        if deadline, ok := ctx.Deadline(); ok { //设置了deadl

            logg.Printf("deadline set")

            if time.Now().After(deadline) {

                logg.Printf(ctx.Err().Error())

                return

            }

        }

        select {

        case <-ctx.Done():

            logg.Printf("done")

            return

        default:

            logg.Printf("work")

        }

    }

}

func timeoutHandler() {

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

    // ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(5*time.Second))

    go doTimeOutStuff(ctx)

    // go doStuff(ctx)

    time.Sleep( * time.Second)

    cancel()

}

:: deadline set

:: work

:: deadline set

:: work

:: deadline set

:: work

:: deadline set

:: work

:: deadline set

:: context deadline exceeded

:: end

WithTimeout

package main

import (

    "math/rand"

    "time"

    "sync"

    "fmt"

    "context"

)

func main()  {

    rand.Seed(time.Now().Unix())

    ctx,_:=context.WithTimeout(context.Background(),time.Second*)

    var wg sync.WaitGroup

    wg.Add()

    go GenUsers(ctx,&wg)

    wg.Wait()

    fmt.Println("生成幸运用户成功")

}

func GenUsers(ctx context.Context,wg *sync.WaitGroup)  { //生成用户ID

fmt.Println("开始生成幸运用户")

   users:=make([]int,)

   guser:for{

        select{

           case <- ctx.Done(): //代表父context发起 取消操作

             fmt.Println(users)

               wg.Done()

             break guser

             return

        default:

            users=append(users,getUserID(,))

        }

   }

}

func getUserID(min int ,max int) int  {

    return rand.Intn(max-min)+min

}

context deadline exceeded就是ctx超时的时候ctx.Err的错误消息。

搜索测试程序

完整代码参见官方文档Go Concurrency Patterns: Context，其中关键的地方在于函数httpDo

func httpDo(ctx context.Context, req *http.Request, f func(*http.Response, error) error) error {

    // Run the HTTP request in a goroutine and pass the response to f.

    tr := &http.Transport{}

    client := &http.Client{Transport: tr}

    c := make(chan error, )

    go func() { c <- f(client.Do(req)) }()

    select {

    case <-ctx.Done():

        tr.CancelRequest(req)

        <-c // Wait for f to return.

        return ctx.Err()

    case err := <-c:

        return err

    }

}

httpDo关键的地方在于

 select {

    case <-ctx.Done():

        tr.CancelRequest(req)

        <-c // Wait for f to return.

        return ctx.Err()

    case err := <-c:

        return err

    }

要么ctx被取消，要么request请求出错。

httpserver中实现超时

package main

import (

    "net/http"

    "context"

    "time"

)

func CountData(c chan string) chan string {

    time.Sleep(time.Second*)

    c<- "统计结果"

    return c

}

type IndexHandler struct {}

func(this *IndexHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)  {

    if r.URL.Query().Get("count")==""{

        w.Write([]byte("这是首页"))

    }else {

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

        defer cancel()

        c:=make(chan string)

        go CountData(c)

        select {

           case <-ctx.Done():

               w.Write([]byte("超时"))

            case ret:=<-c:

                w.Write([]byte(ret))

        }

    }

}

func main()  {

     mux:=http.NewServeMux()

     mux.Handle("/",new(IndexHandler))

     http.ListenAndServe(":8082",mux)

}

WithValue

func WithValue(parent Context, key interface{}, val interface{}) Context

// NewContext returns a new Context carrying userIP.

func NewContext(ctx context.Context, userIP net.IP) context.Context {

    return context.WithValue(ctx, userIPKey, userIP)

}

// FromContext extracts the user IP address from ctx, if present.

func FromContext(ctx context.Context) (net.IP, bool) {

    // ctx.Value returns nil if ctx has no value for the key;

    // the net.IP type assertion returns ok=false for nil.

    userIP, ok := ctx.Value(userIPKey).(net.IP)

    return userIP, ok

}