Golang Context使用小结

2019年04月27日 计算机

1 场景

我们知道，在 Go 服务端，每个进入的请求会被其所属 goroutine 处理。

例如，如下代码，每次请求，Handler 会创建一个 goroutine 来为其提供服务，而且连续请求 3 次，r 的地址也是不同的。

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
        fmt.Println(&r)
        w.Write([]byte("hello"))
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

$ go run test.go

$ curl http://localhost:8080/echo
$ curl http://localhost:8080/echo
$ curl http://localhost:8080/echo

0xc000072040
0xc000072048
0xc000072050

而每个请求对应的 Handler，常会启动额外的的 goroutine 进行数据查询或 PRC 调用等。

而当请求返回时，这些额外创建的 goroutine 需要及时回收。而且，一个请求对应一组请求域内的数据可能会被该请求调用链条内的各 goroutine 所需要。

例如，在如下代码中，当请求进来时，Handler 会创建一个监控 goroutine，其会每隔 1s 打印一句“req is processing”。

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
        // monitor
        go func() {
            for range time.Tick(time.Second) {
                fmt.Println("req is processing")
            }
        }()

        // assume req processing takes 3s
        time.Sleep(3 * time.Second)
        w.Write([]byte("hello"))
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

假定请求需耗时 3s，即请求在 3s 后返回，我们期望监控 goroutine 在打印 3 次“req is processing”后即停止。但运行发现，监控 goroutine 打印 3 次后，其仍不会结束，而会一直打印下去。

问题出在创建监控 goroutine 后，未对其生命周期作控制，下面我们使用 context 作一下控制，即监控程序打印前需检测r.Context()是否已经结束，若结束则退出循环，即结束生命周期。

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
        // monitor
        go func() {
            for range time.Tick(time.Second) {
                select {
                case <-r.Context().Done():
                    fmt.Println("req is outgoing")
                    return
                default:
                    fmt.Println("req is processing")
                }
            }
        }()

        // assume req processing takes 3s
        time.Sleep(3 * time.Second)
        w.Write([]byte("hello"))
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

基于如上需求，context 包应运而生。

context 包可以提供一个请求从 API 请求边界到各 goroutine 的请求域数据传递、取消信号及截止时间等能力。

2 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 方法返回一个 channel，当 Context 取消或到达截止时间时，该 channel 即会关闭。Err 方法返回 Context 取消的原因。

Context 自己没有 Cancel 方法，而且 Done channel 仅用来接收信号：接收取消信号的函数不应同时是发送取消信号的函数。父 goroutine 启动子 goroutine 来做一些子操作，而子 goroutine 不应用来取消父 goroutine。

Context 是安全的，可被多个 goroutine 同时使用。一个 Context 可以传给多个 goroutine，而且可以给所有这些 goroutine 发取消信号。

若有截止时间，Deadline 方法可以返回该 Context 的取消时间。

Value 允许 Context 携带请求域内的数据，该数据访问必须保障多个 goroutine 同时访问的安全性。

3 衍生 Context

// 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

// WithCancel returns a copy of parent whose Done channel is closed as soon as
// parent.Done is closed or cancel is called.
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

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

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

// WithTimeout returns a copy of parent whose Done channel is closed as soon as
// parent.Done is closed, cancel is called, or timeout elapses. The new
// Context's Deadline is the sooner of now+timeout and the parent's deadline, if
// any. If the timer is still running, the cancel function releases its
// resources.
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

// WithValue returns a copy of parent whose Value method returns val for key.
func WithValue(parent Context, key interface{}, val interface{}) Context

context 包提供从已有 Context 衍生新的 Context 的能力。这样即可形成一个 Context 树，当父 Context 取消时，所有从其衍生出来的子 Context 亦会被取消。

Background 是所有 Context 树的根，其永远不会被取消。

使用 WithCancel 及 WithTimeout 可以创建衍生的 Context，WithCancel 可用来取消一组从其衍生的 goroutine，WithTimeout 可用来设置截止时间。

WithValue 提供给 Context 赋予请求域数据的能力。

下面来看几个对如上方法使用的例子。

1）首先，看一下 WitchCancel 的使用

在如下代码中，main 函数使用 WithCancel 创建一个基于 Background 的 ctx。

然后启动一个 monitor goroutine，该 monitor 每隔 1s 打印一句“monitor woring”，main 函数在 3s 后执行 cancel，那么 monitor 检测到取消信号后即会退出。

package main

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

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // monitor
    go func() {
        for range time.Tick(time.Second) {
            select {
            case <-ctx.Done():
                return
            default:
                fmt.Println("monitor woring")
            }
        }
    }()

    time.Sleep(3 * time.Second)
}

2）再看一个使用 WithTimeout 的例子

如下代码中使用 WithTimeout 创建一个基于 Background 的 ctx，其会在 3s 后取消。

注意，虽然到截止时间会自动 cancel，但 cancel 代码仍建议加上。

到截止时间而被取消还是被 cancel 代码所取消，取决于哪个信号发送的早。

package main

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

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    select {
    case <-time.After(4 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        fmt.Println(ctx.Err())
    }
}

WithDeadline 的使用与 WithTimeout 相似。

没想好 Context 的具体使用，可以使用 TODO 来占位，也便于工具作正确性检查。

3）最后看一下 WithValue 的使用

如下代码基于 Background 创建一个带值的 ctx，然后可以根据 key 来取值。

注意：避免多个包同时使用 context 而带来冲突，key 不建议使用 string 或其他内置类型，而建议自定义 key 类型。

package main

import (
    "context"
    "fmt"
)

type ctxKey string

func main() {
    ctx := context.WithValue(context.Background(), ctxKey("a"), "a")

    get := func(ctx context.Context, k ctxKey) {
        if v, ok := ctx.Value(k).(string); ok {
            fmt.Println(v)
        }
    }
    get(ctx, ctxKey("a"))
    get(ctx, ctxKey("b"))
}

最后列一下 Context 使用规则：

  • 勿将 Context 作为 struct 的字段使用，而是对每个使用其的函数分别作参数使用，其需定义为函数或方法的第一个参数，一般叫作 ctx；
  • 勿对 Context 参数传 nil，未想好的使用那个 Context，请传context.TODO；
  • 使用 context 传值仅可用作请求域的数据，其它类型数据请不要滥用；
  • 同一个 Context 可以传给使用其的多个 goroutine，且 Context 可被多个 goroutine 同时安全访问。

参考资料

[1]https://blog.golang.org/context

[2]https://golang.org/pkg/context/

#Golang
版权声明：该博客文章由作者通过「知识共享署名 4.0 许可证」进行授权，转载须注明文章原始链接。

相关文章

评论

正在加载评论......