在Go中，每个请求都会在各自所在的goroutine中运行。Context包可以方便地在各个goroutine之间传值和发送取消[1]、达到*最后期限*[2]信号。

Context的接口定义

// Context携带着deadline和取消信号，和request-scoped的值跨域API的界限在goroutine之间传递，
// 且保证是同步安全的
type Context interface {
    // 当此Context取消或者超时，Done返回一个channel
    Done() <-chan struct{}

    // 此context被取消的错误原因
    Err() error

    // Deadline返回什么时候Context由于超时会被取消
    Deadline() (deadline time.Time, ok bool)

    // request-scoped需要共享的值
    Value(key interface{}) interface{}
}

获取Context

Context值是以树状结构呈现的，如果Context被取消，那么他的子Context也会被取消。

Background是Context树的根，它不能被取消：

// Background返回一个空Context。它不允许被取消，没有最后期限，没有值。
// Background被用在main，init和tests的地方，作为进来的请求的最顶级Context。
func Background() Context

WithCancel和WithTimeout返回的Conetxt是可以被取消的。此Context关联的请求处理完成返回时，就会被取消。WithCancel多用于关联冗余请求，WithTimeout多用于关联后台服务要求设置超时的请求。

// WithCancel返回一个parent Context的副本，当parent的Done Channel被关闭，或者cancel被调用，
// 那么它的Done Channel也会被关闭
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

// A CancelFunc cancels a Context.
type CancelFunc func()

// WithTimeout返回一个parent Context的副本，当parent的Done Channel被关闭，或者cancel被调用，
// 或者超时时间已到，那么它的Done Channel也会被关闭。
// 此新Context的最后期限必须比now + timeout要早。如果timer仍然在运行，那么cancel方法会释放资源。
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

WithValue提供了一个关联request-scoped值的方法。

// WithValue返回一个Parent的副本，它的Value方法返回key匹配的val值
func WithValue(parent Context, key interface{}, val interface{}) Context

下面提供一个最佳实践。

例子：Google Web Search

我们的例子是处理一个http请求，URL是/search?q=golang&timeout=1s表示查询golang关键字，timeout参数表示请求的超时时间，最后调用Google Web Search API获取数据并渲染结果。

代码分成三个包：

• server提供main方法和处理/search请求
• userip提供抽取IP地址，并把它关联到Context的方法
• google提供Search方法，调用google的api

server代码

此处理器创建第一个Context，称为ctx；同时把它设置为当处理返回后被取消。如果URL包含timeout参数，此Context超时后也会被自动取消。

func handleSearch(w http.ResponseWriter, req *http.Request) {
    // ctx是此处理器的Context。调用cancel方法会关闭ctx.Done channel，此取消信号是此处理器发出
    var (
        ctx    context.Context
        cancel context.CancelFunc
    )
    timeout, err := time.ParseDuration(req.FormValue("timeout"))
    if err == nil {
        // 此请求有超时入参，所以此context超时后会被自动取消
        ctx, cancel = context.WithTimeout(context.Background(), timeout)
    } else {
        ctx, cancel = context.WithCancel(context.Background())
    }
    // handleSearch返回后发送取消信号，取消ctx
    defer cancel()

此处理器在请求里抽取出客户端IP地址，然后调用userip包的方法。此客户端IP地址在后面的请求中会用到，所以handleSearch把它附在ctx里：

    // 获取入参q的值并校验
    query := req.FormValue("q")
    if query == "" {
        http.Error(w, "no query", http.StatusBadRequest)
        return
    }

        // 使用其他包的代码存储客户端IP地址
    userIP, err := userip.FromRequest(req)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    ctx = userip.NewContext(ctx, userIP)

此处理器调用google.Search方法，并带上了ctx和query。

    // Run the Google search and print the results.
    start := time.Now()
    results, err := google.Search(ctx, query)
    elapsed := time.Since(start)

如果请求成功，此处理器渲染结果：

    if err := resultsTemplate.Execute(w, struct {
        Results          google.Results
        Timeout, Elapsed time.Duration
    }{
        Results: results,
        Timeout: timeout,
        Elapsed: elapsed,
    }); err != nil {
        log.Print(err)
        return
    }

userip包

userip包提供从请求抽取IP地址和把IP地址关联到Context的功能。Context提供key-value映射关系存储。

为了避免key发生碰撞，userip定义一个私有类型key，使用此类型的值作为Context的key：

// 此key类型是私有的，避免与其他包所定义的key发生碰撞
type key int

// userIPkey是客户端IP地址的Context key。如果此包定义了其他的Context key，他们需要使用其他整数值
const userIPKey key = 0

FromRequest从http.Request抽取出客户端IP地址userIP：

func FromRequest(req *http.Request) (net.IP, error) {
    ip, _, err := net.SplitHostPort(req.RemoteAddr)
    if err != nil {
        return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
    }

NewContext返回一个新的Context，携带着userIP值：

func NewContext(ctx context.Context, userIP net.IP) context.Context {
    return context.WithValue(ctx, userIPKey, userIP)
}

FromContext 从 Context获取 userIP 值：

func FromContext(ctx context.Context) (net.IP, bool) {
    // 如果不存在此key对应的value，ctx.Value返回nil
    userIP, ok := ctx.Value(userIPKey).(net.IP)
    return userIP, ok
}

google包

google.Search 方法创建一个HTTP请求 Google Web Search API 接口，并把结果解析成JSON结构。它接受一个Context类型的参数ctx，并且当请求没有响应导致 ctx.Done 被关闭时会马上返回。

func Search(ctx context.Context, query string) (Results, error) {
    // 准备Google Search API请求.
    req, err := http.NewRequest("GET", "https://ajax.googleapis.com/ajax/services/search/web?v=1.0", nil)
    if err != nil {
        return nil, err
    }
    q := req.URL.Query()
    // 参数1
    q.Set("q", query)

    // If ctx is carrying the user IP address, forward it to the server.
    // Google APIs use the user IP to distinguish server-initiated requests
    // from end-user requests.
    // 
    if userIP, ok := userip.FromContext(ctx); ok {
        // 参数2
        q.Set("userip", userIP.String())
    }
    req.URL.RawQuery = q.Encode()

Search 使用了一个辅助方法， httpDo，发起HTTP请求，如果 ctx.Done 在处理请求或响应时关闭了HTTP请求，则将其取消。Search 传递了一个闭包方法来处理HTTP响应。

    var results Results
    err = httpDo(ctx, req, func(resp *http.Response, err error) error {
        if err != nil {
            return err
        }
        defer resp.Body.Close()

        // Parse the JSON search result.
        // https://developers.google.com/web-search/docs/#fonje
        var data struct {
            ResponseData struct {
                Results []struct {
                    TitleNoFormatting string
                    URL               string
                }
            }
        }
        if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
            return err
        }
        for _, res := range data.ResponseData.Results {
            results = append(results, Result{Title: res.TitleNoFormatting, URL: res.URL})
        }
        return nil
    })
    // httpDo waits for the closure we provided to return, so it's safe to
    // read results here.
    return results, err

httpDo 方法会在一个新的goroutine中运行HTTP请求和处理其响应。如果ctx.Done在goroutine退出之前已关闭，它将取消请求：

func httpDo(ctx context.Context, req *http.Request, f func(*http.Response, error) error) error {
    // 在一个goroutine中运行一个HTTP请求，并且把处理响应的逻辑方法传递到f入参
    c := make(chan error, 1)
    req = req.WithContext(ctx)
    go func() { c <- f(http.DefaultClient.Do(req)) }()
    select {
    case <-ctx.Done():
        <-c // Wait for f to return.
        return ctx.Err()
    case err := <-c:
        return err
    }
}

在Google，我们要求Go程序员必须把Context作为第一入参传递到每个有传入传出的请求函数中。这样可以使不同的Go开发团队很好地进行互动操作。他提供对超时和取消的简单控制，并保证安全凭证之类的关键值正确地传导到Go程序。

有疑问加站长微信联系（非本文作者）