go - context 用法

比眉伴天荒 2022-06-05 00:17 223阅读 0赞

# 1，context作用 #

1，通过context，我们可以方便地对同一个请求所产生地goroutine进行约束管理，可以设定超时、deadline，甚至是取消这个请求相关的所有goroutine。形象地说，假如一个请求过来，需要A去做事情，而A让B去做一些事情，B让C去做一些事情，A、B、C是三个有关联的goroutine，那么问题来了：假如在A、B、C还在处理事情的时候请求被取消了，那么该如何优雅地同时关闭goroutine A、B、C呢？这个时候就轮到context包上场了。

2，在golang中的创建一个新的线程并不会返回像c语言类似的pid所有我们不能从外部杀死某个线程，所有我就得让它自己结束之前我们用channel＋select的方式，来解决这个问题但是有些场景实现起来比较麻烦，例如由一个请求衍生出多个线程并且之间需要满足一定的约束关系，以实现一些诸如：

> 有效期，中止线程树，传递请求全局变量之类的功能。

于是google 就为我们提供一个解决方案，开源了context包。使用context包来实现上下文功能 …..  
约定：需要在你的方法的传入参数的第一个参数是context.Context的变量。

# 2，context结构 #

使用例子（1）：

package main
    
    import (
        "context"
        "fmt"
    )
    
    func main() {
        // gen generates integers in a separate goroutine and
        // sends them to the returned channel.
        // The callers of gen need to cancel the context once
        // they are done consuming generated integers not to leak
        // the internal goroutine started by gen.
        // 定义 goroutine 函数
        gen := func(ctx context.Context) <-chan int {
            dst := make(chan int)
            n := 1
            go func() {
                for {
                    select {
                    case <-ctx.Done():
                        return // returning not to leak the goroutine
                    case dst <- n:
                        n++
                    }
                }
            }()
            return dst
        }
    
        ctx, cancel := context.WithCancel(context.Background())
        defer cancel() // main 方法执行完后，结束 ctx 相关的 goroutine
    
        for n := range gen(ctx) {
            fmt.Println(n)
            if n == 5 {
                break
            }
        }
    }

使用例子（2）:

package main
    import (
        "fmt"
        "time"
        "golang.org/x/net/context"
    )
    func Cdd(ctx context.Context) int {
        fmt.Println(ctx.Value("NLJB"))
        select {
        // 结束时候做点什么 ...
        case <-ctx.Done():
            return -3
        default:
            // 没有结束 ... 执行 ...
        }
    }
    func Bdd(ctx context.Context) int {
        fmt.Println(ctx.Value("HELLO"))
        fmt.Println(ctx.Value("WROLD"))
        ctx = context.WithValue(ctx, "NLJB", "NULIJIABEI")
        go fmt.Println(Cdd(ctx))
        select {
        // 结束时候做点什么 ...
        case <-ctx.Done():
            return -2
        default:
            // 没有结束 ... 执行 ...
        }
    }
    func Add(ctx context.Context) int {
        ctx = context.WithValue(ctx, "HELLO", "WROLD")
        ctx = context.WithValue(ctx, "WROLD", "HELLO")
        go fmt.Println(Bdd(ctx))
        select {
        // 结束时候做点什么 ...
        case <-ctx.Done():
            return -1
        default:
            // 没有结束 ... 执行 ...
        }
    }
    func main() {
        // 自动取消(定时取消)
        {
            timeout := 3 * time.Second
            ctx, _ := context.WithTimeout(context.Background(), timeout)
            fmt.Println(Add(ctx))
        }
        // 手动取消
        // { 
        // ctx, cancel := context.WithCancel(context.Background())
        // go func() { 
        // time.Sleep(2 * time.Second)
        // cancel() // 在调用处主动取消
        // }()
        // fmt.Println(Add(ctx))
        // }
        select {}
    }

## （1）context.Context 接口 ##

*  context包里的方法是线程安全的，可以被多个线程使用
 *  当Context被canceled或是timeout, Done返回一个被closed 的channel
 *  在Done的channel被closed后, Err代表被关闭的原因
 *  如果存在, Deadline 返回Context将要关闭的时间
 *  如果存在，Value 返回与 key 相关了的值，不存在返回 nil

// context 包的核心
    type Context interface {                
        Done() <-chan struct{}      
        Err() error 
        Deadline() (deadline time.Time, ok bool)
        Value(key interface{ }) interface{ }
    }

*  Deadline会返回一个超时时间，Goroutine获得了超时时间后，例如可以对某些io操作设定超时时间。
 *  Done方法返回一个信道（channel）。当Context被cancenl或timeout时，该信道被关闭。它是一个表示Context是否已关闭的信号。
 *  当Done信道关闭后，Err方法表明Context被撤的原因。
 *  Value可以让Goroutine共享一些数据，当然获得数据是协程安全的。但使用这些数据的时候要注意同步，比如返回了一个map，而这个map的读写则要加锁。

### （2）接口的实现 ###

我们不需要手动实现这个接口，context 包已经给我们提供了两个

*  Background
 *  TODO

这两个函数都会返回一个Context的实例只是返回的这两个实例都是空 Context。

/* TODO返回一个非nil，empty的上下文 在目前还不清楚要使用的上下文或尚不可用时 */
    context.TODO()
    /* Background返回一个非nil，empty的上下文。 这是没有取消，没有值，并且没有期限。 它通常用于由主功能，初始化和测试，并作为输入的顶层上下文 */
    context.Background()

## 3，context包里的方法 ##

### （1）方法的使用 ###

Context接口没有提供方法来设置其值和过期时间，也没有提供方法直接将其自身撤销。也就是说，Context不能改变和撤销其自身。那么该怎么通过Context传递改变后的状态呢？

context包里，主要使用的方法：

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
    func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
    func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
    func WithValue(parent Context, key interface{}, val interface{}) Context

*  WithCancel 对应的是 cancelCtx ,其中，返回一个 cancelCtx ，同时返回一个 CancelFunc，CancelFunc 是 context 包中定义的一个函数类型：type CancelFunc func()。调用这个 CancelFunc 时，关闭对应的c.done，也就是让他的后代goroutine退出
 *  WithDeadline 和 WithTimeout 对应的是 timerCtx ，WithDeadline 和 WithTimeout 是相似的，WithDeadline 是设置具体的 deadline 时间，到达 deadline 的时候，后代 goroutine 退出，而 WithTimeout 简单粗暴，直接 return WithDeadline(parent, time.Now().Add(timeout))
 *  WithValue 对应 valueCtx ，WithValue 是在 Context 中设置一个 map，拿到这个 Context 以及它的后代的 goroutine 都可以拿到 map 里的值

Context 的调用应该是链式的，通过WithCancel，WithDeadline，WithTimeout或WithValue派生出新的 Context。当父 Context 被取消时，其派生的所有 Context 都将取消。

通过context.WithXXX都将返回新的 Context 和 CancelFunc。调用 CancelFunc 将取消子代，移除父代对子代的引用，并且停止所有定时器。未能调用 CancelFunc 将泄漏子代，直到父代被取消或定时器触发。go vet工具检查所有流程控制路径上使用 CancelFuncs。

### （2）context的创建 ###

所有的context的父对象，也叫根对象，是一个空的context，它不能被取消，它没有值，从不会被取消，也没有超时时间，它常常作为处理request的顶层context存在，然后通过WithCancel、WithTimeout函数来创建子对象来获得cancel、timeout的能力

当顶层的request请求函数结束后，我们就可以cancel掉某个context，从而通知别的routine结束

# 其它方法例子 #

请参考：[快速掌握 Golang context 包，简单示例][Golang context]

# 参考 #

[快速掌握 Golang context 包，简单示例][Golang context]  
[理解Go Context机制][Go Context]  
[Golang之Context的使用][Golang_Context]  
[golang context初探][golang context]

# 未读文章 #

[How to correctly use context.Context in Go 1.7][]  
[Context API explained][]  
[Go Concurrency Patterns: Context][Go Concurrency Patterns_ Context]

[Golang context]: https://deepzz.com/post/golang-context-package-notes.html
[Go Context]: http://lanlingzi.cn/post/technical/2016/0802_go_context/
[Golang_Context]: http://www.nljb.net/default/Golang%E4%B9%8BContext%E7%9A%84%E4%BD%BF%E7%94%A8/
[golang context]: http://www.jianshu.com/p/0dc7596ba90a
[How to correctly use context.Context in Go 1.7]: https://medium.com/@cep21/how-to-correctly-use-context-context-in-go-1-7-8f2c0fafdf39
[Context API explained]: https://siadat.github.io/post/context
[Go Concurrency Patterns_ Context]: https://blog.golang.org/context