go笔记--几个例子理解context的作用

浅浅的花香味﹌ 2023-06-30 13:53 2阅读 0赞

# go笔记–几个例子理解context的作用 #

### 文章目录 ###

*  go笔记--几个例子理解context的作用
 *   *  context interface
     *   *  先看一个简单的例程
         *  context的作用
         *  contxt相关函数

--------------------

经常在http框架里面看到一个context参数，它是做什么的呢，先简单看看它的定义。

## context interface ##

type Context interface {
        
        // Deadline returns the time when work done on behalf of this context
        // should be canceled. Deadline returns ok==false when no deadline is
        // set. Successive calls to Deadline return the same results.
        Deadline() (deadline time.Time, ok bool)
    
        // Done returns a channel that's closed when work done on behalf of this
        // context should be canceled. Done may return nil if this context can
        // never be canceled. Successive calls to Done return the same value.
        //
        // WithCancel arranges for Done to be closed when cancel is called;
        // WithDeadline arranges for Done to be closed when the deadline
        // expires; WithTimeout arranges for Done to be closed when the timeout
        // elapses.
        //
        // Done is provided for use in select statements:
        //
        //  // Stream generates values with DoSomething and sends them to out
        //  // until DoSomething returns an error or ctx.Done is closed.
        //  func Stream(ctx context.Context, out chan<- Value) error {
        
        //  	for {
        
        //  		v, err := DoSomething(ctx)
        //  		if err != nil {
        
        //  			return err
        //  		}
        //  		select {
        
        //  		case <-ctx.Done():
        //  			return ctx.Err()
        //  		case out <- v:
        //  		}
        //  	}
        //  }
        //
        // See https://blog.golang.org/pipelines for more examples of how to use
        // a Done channel for cancelation.
        Done() <-chan struct{
        }
    
        // Err returns a non-nil error value after Done is closed. Err returns
        // Canceled if the context was canceled or DeadlineExceeded if the
        // context's deadline passed. No other values for Err are defined.
        // After Done is closed, successive calls to Err return the same value.
        Err() error
    
        // Value returns the value associated with this context for key, or nil
        // if no value is associated with key. Successive calls to Value with
        // the same key returns the same result.
        //
        // Use context values only for request-scoped data that transits
        // processes and API boundaries, not for passing optional parameters to
        // functions.
        //
        // A key identifies a specific value in a Context. Functions that wish
        // to store values in Context typically allocate a key in a global
        // variable then use that key as the argument to context.WithValue and
        // Context.Value. A key can be any type that supports equality;
        // packages should define keys as an unexported type to avoid
        // collisions.
        //
        // Packages that define a Context key should provide type-safe accessors
        // for the values stored using that key:
        //
        // 	// Package user defines a User type that's stored in Contexts.
        // 	package user
        //
        // 	import "context"
        //
        // 	// User is the type of value stored in the Contexts.
        // 	type User struct {...}
        //
        // 	// key is an unexported type for keys defined in this package.
        // 	// This prevents collisions with keys defined in other packages.
        // 	type key int
        //
        // 	// userKey is the key for user.User values in Contexts. It is
        // 	// unexported; clients use user.NewContext and user.FromContext
        // 	// instead of using this key directly.
        // 	var userKey key = 0
        //
        // 	// NewContext returns a new Context that carries value u.
        // 	func NewContext(ctx context.Context, u *User) context.Context {
        
        // 		return context.WithValue(ctx, userKey, u)
        // 	}
        //
        // 	// FromContext returns the User value stored in ctx, if any.
        // 	func FromContext(ctx context.Context) (*User, bool) {
        
        // 		u, ok := ctx.Value(userKey).(*User)
        // 		return u, ok
        // 	}
        Value(key interface{
        }) interface{
        }
    }

可以看到它一个接口类型、主要包含4个成员，我们暂时不知道它们的意义。

Deadline() (deadline time.Time, ok bool)
    
        Done() <-chan struct{}
    
        Err() error
    
        Value(key interface{}) interface{}

### 先看一个简单的例程 ###

package main
    
    import (
    	"context"
    	"fmt"
    	"time"
    )
    
    func cancel1() {
        
    		// 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.
    	gen := func(ctx context.Context) <-chan int {
        
    		dst := make(chan int)
    		n := 1
    		go func() {
        
    			for {
        
    				select {
        
    				case <-ctx.Done():
    					fmt.Println("ctx.Done()")
    					return // returning not to leak the goroutine
    				case dst <- n:
    					n++
    				}
    			}
    		}()
    		return dst
    	}
    
    	ctx, cancel := context.WithCancel(context.Background())
    	defer cancel() // cancel when we are finished consuming integers
    
    	for n := range gen(ctx) {
        
    		fmt.Println(n)
    		if n == 5 {
        
    			break
    		}
    	}
    }
    
    func main() {
        
    
    	fmt.Println("-----start-----")
    
    	fmt.Println("call cancel1()")
    	go cancel1()
    	fmt.Println("cancel1() end")
    
    	time.Sleep(time.Second)
    	fmt.Println("----end------")
    }

控制台会输出  
![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TYtKKfGz-1579256378305)(./1579254204663.png)\]][img-TYtKKfGz-1579256378305_._1579254204663.png]

我们可以看到，for循环执行了5次 context 的派生函数gen()后，通过cancel()函数退出了gen里面的协程。

那么它在这里的作用也就清楚了:

### context的作用 ###

> 设置截止日期，超时或调用取消函数来通知所有使用任何派生 context 的函数来停止运行并返回。

咱们这是**取消函数**

### contxt相关函数 ###

**withcancel**  
此函数创建从传入的父 context 派生的新 context。父 context 可以是后台 context 或传递给函数的 context。  
返回派生 context 和取消函数。只有创建它的函数才能调用取消函数来取消此 context。

**deadline**

WithDeadline()返回其父项的派生 context，当截止日期超过或取消函数被调用时，该 context 将被取消。例如，您可以创建一个将在以后的某个时间自动取消的 context，并在子函数中传递它。当因为截止日期耗尽而取消该 context 时，获此 context 的所有函数都会收到通知去停止运行并返回。  
小例：

func deadline1() {
        
    	d := time.Now().Add(1200 * time.Millisecond)
    	ctx, cancel := context.WithDeadline(context.Background(), d)
    
    	// Even though ctx will be expired, it is good practice to call its
    	// cancelation function in any case. Failure to do so may keep the
    	// context and its parent alive longer than necessary.
    	defer cancel()
    
    	select {
        
    	case <-time.After(1 * time.Second):
    		fmt.Println("overslept")
    	case <-ctx.Done():
    		fmt.Println(ctx.Err())
    	}
    
    }
    
    func main() {
        
    
    	fmt.Println("-----start-----")
    
    	fmt.Println("call deadline1()")
    	go deadline1()
    	fmt.Println("deadline1() end")
    
    	time.Sleep(3*time.Second)
    	fmt.Println("----end------")
    }

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PhM1BFwd-1579256378306)(./1579254891261.png)\]][img-PhM1BFwd-1579256378306_._1579254891261.png]

withtimeout()和WithDeadline()类似，不同之处在于它将持续时间作为参数输入而不是时间对象。

**timeout**

// Pass a context with a timeout to tell a blocking function that it
    // should abandon its work after the timeout elapses.
    ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
    defer cancel()
    
    select {
    case <-time.After(1 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        fmt.Println(ctx.Err()) // prints "context deadline exceeded"
    }
    
    Output:
    context deadline exceeded

现在再看看这context的interface,就能简单明了它们的意义了。

// 返回超时期限。
        Deadline() (deadline time.Time, ok bool)
    
    	// 辅助cancel
        Done() <-chan struct{
        }
    
    	// 获取返回的错误
        Err() error
    
        Value(key interface{
        }) interface{
        }

可是还有个Value， 那我们再看看。

还有一个withValue() 函数 、  
此函数接收 context 并返回派生 context，其中值 val 与 key 关联，并通过 context 树与 context 一起传递。这意味着一旦获得带有值的 context，从中派生的任何 context 都会获得此值。不建议使用 context 值传递关键参数，而是函数应接收签名中的那些值，使其显式化。

Code: 
    type favContextKey string
    
    f := func(ctx context.Context, k favContextKey) {
        
        if v := ctx.Value(k); v != nil {
        
            fmt.Println("found value:", v)
            return
        }
        fmt.Println("key not found:", k)
    }
    
    k := favContextKey("language")
    ctx := context.WithValue(context.Background(), k, "Go")
    
    f(ctx, k)
    f(ctx, favContextKey("color"))
    
    Output:
    found value: Go
    key not found: color

那么明显了 Value(key interface\{\}) interface\{\} 返回的即是context关联的键值。

[img-TYtKKfGz-1579256378305_._1579254204663.png]: https://img-blog.csdnimg.cn/20200117182015516.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE3MzA4MzIx,size_16,color_FFFFFF,t_70
[img-PhM1BFwd-1579256378306_._1579254891261.png]: https://img-blog.csdnimg.cn/20200117182005417.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE3MzA4MzIx,size_16,color_FFFFFF,t_70