一文搞懂Go语言Context

简介: 一文搞懂Go语言Context

0 前置知识sync.WaitGroup

sync.WaitGroup是等待一组协程结束。它实现了一个类似任务队列的结构,可以向队列中加入任务,任务完成后就把任务从队列中移除,如果队列中的任务没有全部完成,队列就会触发阻塞以阻止程序继续运行。

sync.WaitGroup只有3个方法,Add(),Done(),Wait()

其中Done()是Add(-1)的别名,使用Add()添加计数,Done()减掉一个计数,计数不为0, 阻塞Wait()的运行。

示例:

package main
import (
   "fmt"
   "sync"
   "time"
)
var group sync.WaitGroup
func sayHello() {
   for i := 0; i < 5; i++ {
      fmt.Println("hello......")
      time.Sleep(time.Second)
   }
   //线程结束 -1
   group.Done()
}
func sayHi() {
   //线程结束 -1
   defer group.Done()
   for i := 0; i < 5; i++ {
      fmt.Println("hi......")
      time.Sleep(time.Second)
   }
}
func main() {
   //+2
   group.Add(2)
   fmt.Println("main正在阻塞...")
   go sayHello()
   fmt.Println("main持续阻塞...")
   go sayHi()
   //线程等待
   group.Wait()
   fmt.Println("main貌似结束了阻塞...")
}
复制代码

效果:

网络异常,图片无法展示
|


1 简介

在 Go 服务器中,每个传入请求都在其自己的 goroutine 中处理。请求处理程序通常会启动额外的 goroutine 来访问后端,例如数据库和 RPC 服务。处理请求的一组 goroutine 通常需要访问特定于请求的值,例如最终用户的身份、授权令牌和请求的截止日期。当请求被取消或超时时,处理该请求的所有 goroutine 都应该快速退出,以便系统可以回收它们正在使用的任何资源。

为此,开发了一个context包,可以轻松地将请求范围的值、取消信号和截止日期跨 API 边界传递给处理请求所涉及的所有 goroutine。

Context携带一个截止日期、一个取消信号和其他跨越API边界的值。上下文的方法可以被多个gor例程同时调用。

对服务器的传入请求应该创建一个上下文,对服务器的传出调用应该接受一个上下文。它们之间的函数调用链必须传播 Context,可选择将其替换为使用 WithCancel、WithDeadline、WithTimeout 或 WithValue 创建的派生 Context。当一个上下文被取消时,所有从它派生的上下文也被取消。

WithCancel、WithDeadline 和 WithTimeout 函数采用 Context(父)并返回派生的 Context(子)和 CancelFunc。调用 CancelFunc 会取消子项及其子项,删除父项对子项的引用,并停止任何关联的计时器。调用 CancelFunc 失败会泄漏子项及其子项,直到父项被取消或计时器触发。go vet 工具检查是否在所有控制流路径上使用了 CancelFuncs。

使用上下文的程序应遵循以下规则,以保持跨包的接口一致,并启用静态分析工具来检查上下文传播:

不要将上下文存储在结构类型中;相反,将 Context 显式传递给需要它的每个函数。Context 应该是第一个参数,通常命名为 ctx:

func DoSomething(ctx context.Context, arg Arg) error { 
  // ... 使用 ctx ... 
}
复制代码

即使函数允许,也不要传递 nil 上下文。如果不确定要使用哪个 Context,请传递 context.TODO。

仅将上下文值用于传输流程和 API 的请求范围数据,而不用于将可选参数传递给函数。

相同的 Context 可以传递给在不同的 goroutine 中运行的函数;上下文对于多个 goroutine 同时使用是安全的。

网络异常,图片无法展示
|


2 context.Context引入

//上下文携带截止日期、取消信号和请求范围的值在API的界限。它的方法是安全的同时使用多个了goroutine。
type Context interface {
    // Done返回一个在上下文被取消或超时时关闭的通道。
    Done() <-chan struct{}
    // Err表示在Done通道关闭后为何取消此上下文。
    Err() error
    // Deadline返回上下文将被取消的时间(如果有的话)。
    Deadline() (deadline time.Time, ok bool)
    // Value返回与key相关的值,如果没有则返回nil。
    Value(key interface{}) interface{}
}
复制代码
  • Done方法返回一个通道,该通道作为代表运行的函数的取消信号Context:当通道关闭时,函数应该放弃它们的工作并返回。
  • Err方法返回一个错误,指示Context取消的原因。
  • 一个Context对于多个 goroutine 同时使用是安全的。代码可以将单个传递Context给任意数量的 goroutines 并取消它Context以向所有goroutine 发出信号。
  • Deadline方法允许函数确定它们是否应该开始工作,还可以使用截止日期来设置 I/O 操作的超时时间。
  • Value允许一个Context携带请求范围的数据。该数据必须是安全的,以便多个 goroutine 同时使用。

3 context包的其他常用函数

3.1 context.Background和context.TODO

Background是任何Context树的根,它永远不会被取消:

//Background返回一个空的Context。 它永远不会取消,没有截止日期,没有价值。 Background通常用于main、init和tests,并作为传入请求的顶级上下文。  
func Background() Context
复制代码

给一个函数方法传递Context的时候,不要传递nil,如果不知道传递什么,就使用context.TODO()

3.2 context.WithCancel和

WithCancelt返回派生的Context值,可以比父Context更快地取消。当请求处理程序返回时,通常会取消与传入请求关联的content。当使用多个副本时,WithCancel对于取消冗余请求也很有用。

// WithCancel返回一个父进程的副本,该父进程的Done通道被尽快关闭。 关闭Done或调用cancel。
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
// CancelFunc取消一个上下文。
type CancelFunc func()
复制代码

示例:

package main
import (
   "context"
   "fmt"
)
func play(ctx context.Context) <-chan int {
   dist := make(chan int)
   n := 1
   //匿名函数 向dist中加入元素
   go func() {
      for {
         select {
         //ctx为空时将不会执行这个
         case <-ctx.Done():
            return // return结束该goroutine,防止泄露
            //向dist中加入元素
         case dist <- n:
            n++
         }
      }
   }()
   return dist
}
func main() {
   //返回空的context
   ctx, cancel := context.WithCancel(context.Background())
   defer cancel() // 调用cancel
   for n := range play(ctx) {
      fmt.Println(n)
      if n == 5 {
         break
      }
   }
}
复制代码

扩展:go中select的用法

select的用法与switch语言非常类似,由select开始一个新的选择块,每个选择条件由case语句来描述。
与switch语句相比, select有比较多的限制,其中最大的一条限制就是每个case语句里必须是一个IO操作,大致的结构如下:
```go
select {
   case <-chan1:
      // 如果chan1成功读到数据,则进行该case处理语句
   case chan2 <- 1:
      // 如果成功向chan2写入数据,则进行该case处理语句
   default:
      // 如果上面都没有成功,则进入default处理流程
}
```
在一个select语句中,Go语言会按顺序从头至尾评估每一个发送和接收的语句。
如果其中的任意一语句可以继续执行(即没有被阻塞),那么就从那些可以执行的语句中任意选择一条来使用。
如果没有任意一条语句可以执行(即所有的通道都被阻塞),那么有两种可能的情况:
- 如果给出了default语句,那么就会执行default语句,同时程序的执行会从select语句后的语句中恢复。
- 如果没有default语句,那么select语句将被阻塞,直到至少有一个通信可以进行下去。
复制代码

3.3 context.WithTimeout

WithTimeout返回派生的Context值,WithTimeout用于设置请求到后端服务器的截止日期:

//WithTimeout返回一个父进程的副本,该父进程的Done通道被立即关闭的父母。关闭“完成”、调用“取消”或超时结束。新
//Context的Deadline是现在的更快+timeout和父的Deadline,如果任何。 如果计时器仍然在运行,则cancel函数释放它资源。
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
// CancelFunc取消一个上下文。
type CancelFunc func()
复制代码

示例:

package main
import (
   "context"
   "fmt"
   "sync"
   "time"
)
var wg sync.WaitGroup
func worker(ctx context.Context) {
    LOOP:
   for {
      fmt.Println("db connecting ...")
      time.Sleep(time.Millisecond * 10) // 假设正常连接数据库耗时10毫秒
      select {
      case <-ctx.Done(): // 50毫秒后自动调用
         break LOOP
      default:
      }
   }
   fmt.Println("worker done!")
   wg.Done()
}
func main() {
   // 设置一个50毫秒的超时
   ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
   wg.Add(1)
   go worker(ctx)
   time.Sleep(time.Second * 5)
   cancel() // 通知子goroutine结束
   wg.Wait()
   fmt.Println("over")
}
复制代码

执行结果:

网络异常,图片无法展示
|


3.4 context.WithDeadline

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
   if parent == nil {
      panic("cannot create context from nil parent")
   }
   if cur, ok := parent.Deadline(); ok && cur.Before(d) {
      // 目前的期限已经比新的期限提前
      return WithCancel(parent)
   }
   c := &timerCtx{
      cancelCtx: newCancelCtx(parent),
      deadline:  d,
   }
   propagateCancel(parent, c)
   dur := time.Until(d)
   if dur <= 0 {
      c.cancel(true, DeadlineExceeded) // 截止日期已经过去了
      return c, func() { c.cancel(false, Canceled) }
   }
   c.mu.Lock()
   defer c.mu.Unlock()
   if c.err == nil {
      c.timer = time.AfterFunc(dur, func() {
         c.cancel(true, DeadlineExceeded)
      })
   }
   return c, func() { c.cancel(true, Canceled) }
}
复制代码

示例:

package main
import (
   "context"
   "fmt"
   "time"
)
func main() {
   d := time.Now().Add(500 * time.Millisecond)
   ctx, cancel := context.WithDeadline(context.Background(), d)
   // 尽管ctx会过期,但在任何情况下调用它的cancel函数都是很好的实践。
   // 如果不这样做,可能会使上下文及其父类存活的时间超过必要的时间。
   defer cancel()
   select {
   case <-time.After(1 * time.Second):
      fmt.Println("over")
   case <-ctx.Done():
      fmt.Println(ctx.Err())
   }
}
复制代码

执行结果:

网络异常,图片无法展示
|


3.5 context.WithValue

WithValue提供了一种将请求范围的值与Context关联的方法 :

//WithValue返回父元素的副本,其Value方法返回val for key。
func WithValue(parent Context, key interface{}, val interface{}) Context
复制代码

了解如何使用context包的最好方法是通过一个已工作的示例。

示例:

package main
import (
   "context"
   "fmt"
   "sync"
   "time"
)
type TraceCode string
var wg sync.WaitGroup
func worker(ctx context.Context) {
   key := TraceCode("KEY_CODE")
   traceCode, ok := ctx.Value(key).(string) // 在子goroutine中获取trace code
   if !ok {
      fmt.Println("invalid trace code")
   }
    LOOP:
   for {
      fmt.Printf("worker,code:%s\n", traceCode)
      time.Sleep(time.Millisecond * 10) // 假设正常连接数据库耗时10毫秒
      select {
      case <-ctx.Done(): // 50毫秒后自动调用
         break LOOP
      default:
      }
   }
   fmt.Println("worker is over!")
   wg.Done()
}
func main() {
   // 设置一个50毫秒的超时
   ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
   // 在系统的入口中设置trace code传递给后续启动的goroutine实现日志数据聚合
   ctx = context.WithValue(ctx, TraceCode("KEY_CODE"), "12512312234")
   wg.Add(1)
   go worker(ctx)
   time.Sleep(time.Second * 5)
   cancel() // 通知子goroutine结束
   wg.Wait()
   fmt.Println("over")
}
复制代码

执行结果:

网络异常,图片无法展示
|


4 实例:请求浏览器超时

server端

package main
import (
   "fmt"
   "math/rand"
   "net/http"
   "time"
)
// server端,随机出现慢响应
func indexHandler(w http.ResponseWriter, r *http.Request) {
   number := rand.Intn(2)
   if number == 0 {
      time.Sleep(time.Second * 10) // 耗时10秒的慢响应
      fmt.Fprintf(w, "slow response")
      return
   }
   fmt.Fprint(w, "quick response")
}
func main() {
   http.HandleFunc("/", indexHandler)
   err := http.ListenAndServe(":9999", nil)
   if err != nil {
      panic(err)
   }
}
复制代码

client端

package main
import (
   "context"
   "fmt"
   "io/ioutil"
   "net/http"
   "sync"
   "time"
)
// 客户端
type respData struct {
   resp *http.Response
   err  error
}
func doCall(ctx context.Context) {
   // http长连接
   transport := http.Transport{DisableKeepAlives: true}
   client := http.Client{Transport: &transport}
   respChan := make(chan *respData, 1)
   req, err := http.NewRequest("GET", "http://127.0.0.1:9999/", nil)
   if err != nil {
      fmt.Println(err)
      return
   }
   req = req.WithContext(ctx) // 使用带超时的ctx创建一个新的client request
   var wg sync.WaitGroup
   wg.Add(1)
   defer wg.Wait()
   go func() {
      resp, err := client.Do(req)
      fmt.Printf("resp:%v, err:%v\n", resp, err)
      rd := &respData{
         resp: resp,
         err:  err,
      }
      respChan <- rd
      wg.Done()
   }()
   select {
   case <-ctx.Done():
      fmt.Println("timeout...")
   case result := <-respChan:
      fmt.Println("success....")
      if result.err != nil {
         fmt.Printf("err:%v\n", result.err)
         return
      }
      defer result.resp.Body.Close()
      data, _ := ioutil.ReadAll(result.resp.Body)
      fmt.Printf("resp:%v\n", string(data))
   }
}
func main() {
   // 定义一个100毫秒的超时
   ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
   defer cancel() // 调用cancel释放子goroutine资源
   doCall(ctx)
}
复制代码

5 Context包都在哪些地方使用

许多服务器框架提供了用于承载请求作用域值的包和类型。我们可以定义“Context”接口的新实现,在使用现有框架的代码和需要“Context”参数的代码之间架起桥梁。

6 小结

在谷歌中,要求Go程序员将“Context”参数作为传入和传出请求之间的调用路径上的每个函数的第一个参数传递。这使得许多不同团队开发的Go代码能够很好地互操作。它提供了对超时和取消的简单控制,并确保像安全凭证这样的关键值能够正确地传输Go程序。

想要构建在“Context”上的服务器框架应该提供“Context”的实现来连接它们的包和那些需要“Context”参数的包。然后,它们的客户端库将接受来自调用代码的“Context”。通过为请求范围的数据和取消建立一个公共接口,“上下文”使包开发人员更容易共享创建可伸缩服务的代码。

参考文章:

golang.google.cn/pkg/context…

go.dev/blog/contex…


相关文章
|
8月前
|
编译器 Go
揭秘 Go 语言中空结构体的强大用法
Go 语言中的空结构体 `struct{}` 不包含任何字段,不占用内存空间。它在实际编程中有多种典型用法:1) 结合 map 实现集合(set)类型;2) 与 channel 搭配用于信号通知;3) 申请超大容量的 Slice 和 Array 以节省内存;4) 作为接口实现时明确表示不关注值。此外,需要注意的是,空结构体作为字段时可能会因内存对齐原因占用额外空间。建议将空结构体放在外层结构体的第一个字段以优化内存使用。
|
8月前
|
运维 监控 算法
监控局域网其他电脑:Go 语言迪杰斯特拉算法的高效应用
在信息化时代,监控局域网成为网络管理与安全防护的关键需求。本文探讨了迪杰斯特拉(Dijkstra)算法在监控局域网中的应用,通过计算最短路径优化数据传输和故障检测。文中提供了使用Go语言实现的代码例程,展示了如何高效地进行网络监控,确保局域网的稳定运行和数据安全。迪杰斯特拉算法能减少传输延迟和带宽消耗,及时发现并处理网络故障,适用于复杂网络环境下的管理和维护。
|
2月前
|
数据采集 Go API
Go语言实战案例:多协程并发下载网页内容
本文是《Go语言100个实战案例 · 网络与并发篇》第6篇,讲解如何使用 Goroutine 和 Channel 实现多协程并发抓取网页内容,提升网络请求效率。通过实战掌握高并发编程技巧,构建爬虫、内容聚合器等工具,涵盖 WaitGroup、超时控制、错误处理等核心知识点。
|
2月前
|
数据采集 JSON Go
Go语言实战案例:实现HTTP客户端请求并解析响应
本文是 Go 网络与并发实战系列的第 2 篇,详细介绍如何使用 Go 构建 HTTP 客户端,涵盖请求发送、响应解析、错误处理、Header 与 Body 提取等流程,并通过实战代码演示如何并发请求多个 URL,适合希望掌握 Go 网络编程基础的开发者。
|
3月前
|
JSON 前端开发 Go
Go语言实战:创建一个简单的 HTTP 服务器
本篇是《Go语言101实战》系列之一,讲解如何使用Go构建基础HTTP服务器。涵盖Go语言并发优势、HTTP服务搭建、路由处理、日志记录及测试方法,助你掌握高性能Web服务开发核心技能。
|
3月前
|
Go
如何在Go语言的HTTP请求中设置使用代理服务器
当使用特定的代理时,在某些情况下可能需要认证信息,认证信息可以在代理URL中提供,格式通常是:
261 0
|
4月前
|
JSON 编解码 API
Go语言网络编程:使用 net/http 构建 RESTful API
本章介绍如何使用 Go 语言的 `net/http` 标准库构建 RESTful API。内容涵盖 RESTful API 的基本概念及规范,包括 GET、POST、PUT 和 DELETE 方法的实现。通过定义用户数据结构和模拟数据库,逐步实现获取用户列表、创建用户、更新用户、删除用户的 HTTP 路由处理函数。同时提供辅助函数用于路径参数解析,并展示如何设置路由器启动服务。最后通过 curl 或 Postman 测试接口功能。章节总结了路由分发、JSON 编解码、方法区分、并发安全管理和路径参数解析等关键点,为更复杂需求推荐第三方框架如 Gin、Echo 和 Chi。
|
5月前
|
分布式计算 Go C++
初探Go语言RPC编程手法
总的来说,Go语言的RPC编程是一种强大的工具,让分布式计算变得简单如同本地计算。如果你还没有试过,不妨挑战一下这个新的编程领域,你可能会发现新的世界。
124 10
|
8月前
|
存储 Go
Go 语言入门指南:切片
Golang中的切片(Slice)是基于数组的动态序列,支持变长操作。它由指针、长度和容量三部分组成,底层引用一个连续的数组片段。切片提供灵活的增减元素功能,语法形式为`[]T`,其中T为元素类型。相比固定长度的数组,切片更常用,允许动态调整大小,并且多个切片可以共享同一底层数组。通过内置的`make`函数可创建指定长度和容量的切片。需要注意的是,切片不能直接比较,只能与`nil`比较,且空切片的长度为0。
194 3
Go 语言入门指南:切片
|
8月前
|
算法 安全 Go
公司局域网管理系统里的 Go 语言 Bloom Filter 算法,太值得深挖了
本文探讨了如何利用 Go 语言中的 Bloom Filter 算法提升公司局域网管理系统的性能。Bloom Filter 是一种高效的空间节省型数据结构,适用于快速判断元素是否存在于集合中。文中通过具体代码示例展示了如何在 Go 中实现 Bloom Filter,并应用于局域网的 IP 访问控制,显著提高系统响应速度和安全性。随着网络规模扩大和技术进步,持续优化算法和结合其他安全技术将是企业维持网络竞争力的关键。
161 2
公司局域网管理系统里的 Go 语言 Bloom Filter 算法,太值得深挖了