Strcpy

gin.ctx不建议在协程内使用

源代码/数据集已上传到 Github - posts

首先给个结论:千万不要再请求里面,把上下文直接传递到野生goroutine里面

先来看一个现象

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func(ctx *gin.Context) {
_uuid := uuid.New().String()
ctx.Set("uuid", _uuid)
go func(c *gin.Context, u string) {
time.Sleep(time.Second)
cu := c.GetString("uuid")
if cu == u {
log.Printf("一致 %p, %s\n", c, u)
} else {
log.Printf("不一致 %p, uuid = %s, cuuid = %s\n", c, u, cu)
}
}(ctx, _uuid)

ctx.JSON(200, _uuid)
return
}

请求开始生成一个uuid,设置进上下文中。开启一个协程,传入上下文和生成的uuid。协程内sleep一秒后读取上下文中的的uuid是否与与传入的uuid一致。

① 模拟请求,1秒1次

② 模拟请求,1秒2次

③ 模拟请求,压测模式

①中全部是一致
②中不一致少于一致
③出现大量不一致,压测尾部会有少量一致

造成的原因

Gin框架在gin.Run里面实现了调用http.ListenAndServe方法。因为gin.Engine实现了接口http.Handler,并且在http.ListenAndServe的第二位参数将engine传入,所以服务启动后的请求都由gin.ServeHTTP处理。

1
2
3
4
5
6
7
8
9
10
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
c := engine.pool.Get().(*Context)
c.writermem.reset(w)
c.Request = req
c.reset()

engine.handleHTTPRequest(c)

engine.pool.Put(c)
}

解释一下上面的代码。

  1. 当请求进来时,会从上下文的池中获取到一个上下文。当池中没有上下文,则会创建一个新的。
  2. 拿到上下文后,会给上下文初始化responseWriter
  3. 给上下文设置请求体数据
  4. 初始化上下文中的所有数据(除掉第3已设置的参数)
  5. 将上下文传入业务逻辑中
  6. 将上下文放回连接池中

上下文被放回sync.Pool时,没有被重置掉请求的数据。原请求一直持有该上下文的地址,当该上下文没有被二次取出时,原请求去获取上下文中的数据,可以取到一致的数据。

当请求频率间隔小于goroutine退出的时间,上下文在放回池中后又被下一个请求取出,设置上新的uuid,原goroutine拿着上下文的地址去取上下文中的数据,就导致了原goroutine读到了下一个请求的数据,导致出现了不一致。

随着并发量不断加大到一定的量,大量上下文不断被创建,被放进上下文池中,因为sync.Pool的分配策略,可能存在少部分上下文在一段时间内一直不会被取出来二次利用。就会导致,在高并发下,也会有少量的请求是读取到一致的数据。

当高并发接近尾声,不再有新增的请求进去,上下文池中的上下文不再被取出覆盖,又会出现一批一致的请求。

什么场景下可以往goroutine中传递上下文

goroutine非野生goroutine,goroutine在主请求中可以被管控到。在主请求的生命周期内,goroutine创建后退出。
比如下面这种

1
2
3
4
5
6
7
8
9
10
11
12
var wg sync.WaitGroup
wg.Add(2)
go func(ctx *gin.Context) {
defer wg.Done()
fmt.Println("1")
}(ctx)

go func(ctx *gin.Context) {
defer wg.Done()
fmt.Println("2")
}(ctx)
wg.Wait()

如何避免上下文被野生goroutine使用

Gin框架在充分利用资源的同时也给服务带来了风险。所以应该尽量避免往goroutine中传递上下文。

必须要使用该怎么做

gin框架提供了copy方法为不得不使用上下文传递的场景提供支持。
复制后的上下文可以安全地在请求外的使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Copy returns a copy of the current context that can be safely used outside the request's scope.
// This has to be used when the context has to be passed to a goroutine.
func (c *Context) Copy() *Context {
cp := Context{
writermem: c.writermem,
Request: c.Request,
Params: c.Params,
engine: c.engine,
}
cp.writermem.ResponseWriter = nil
cp.Writer = &cp.writermem
cp.index = abortIndex
cp.handlers = nil
cp.Keys = map[string]interface{}{}
for k, v := range c.Keys {
cp.Keys[k] = v
}
paramCopy := make([]Param, len(cp.Params))
copy(paramCopy, cp.Params)
cp.Params = paramCopy
return &cp
}

edit this page last updated at 2022-06-13

Big Image