go语言中http超时引发的事故解决


Posted in Golang onJune 02, 2021

前言

我们使用的是golang标准库的http client,对于一些http请求,我们在处理的时候,会考虑加上超时时间,防止http请求一直在请求,导致业务长时间阻塞等待。

最近同事写了一个超时的组件,这几天访问量上来了,网络也出现了波动,造成了接口在报错超时的情况下,还是出现了请求结果的成功。

分析下具体的代码实现

type request struct {
 method string
 url    string
 value  string
 ps     *params
}

type params struct {
 timeout     int //超时时间
 retry       int //重试次数
 headers     map[string]string
 contentType string
}

func (req *request) Do(result interface{}) ([]byte, error) {
 res, err := asyncCall(doRequest, req)
 if err != nil {
  return nil, err
 }

 if result == nil {
  return res, nil
 }

 switch req.ps.contentType {
 case "application/xml":
  if err := xml.Unmarshal(res, result); err != nil {
   return nil, err
  }
 default:
  if err := json.Unmarshal(res, result); err != nil {
   return nil, err
  }
 }

 return res, nil
}
type timeout struct {
 data []byte
 err  error
}


func doRequest(request *request) ([]byte, error) {
 var (
  req    *http.Request
  errReq error
 )
 if request.value != "null" {
  buf := strings.NewReader(request.value)
  req, errReq = http.NewRequest(request.method, request.url, buf)
  if errReq != nil {
   return nil, errReq
  }
 } else {
  req, errReq = http.NewRequest(request.method, request.url, nil)
  if errReq != nil {
   return nil, errReq
  }
 }
 // 这里的client没有设置超时时间
 // 所以当下面检测到一次超时的时候,会重新又发起一次请求
 // 但是老的请求其实没有被关闭,一直在执行
 client := http.Client{}
 res, err := client.Do(req)
 ...
}

// 重试调用请求
// 当超时的时候发起一次新的请求
func asyncCall(f func(request *request) ([]byte, error), req *request) ([]byte, error) {
 p := req.ps
 ctx := context.Background()
 done := make(chan *timeout, 1)

 for i := 0; i < p.retry; i++ {
  go func(ctx context.Context) {
   // 发送HTTP请求
   res, err := f(req)
   done <- &timeout{
    data: res,
    err:  err,
   }
  }(ctx)
  // 错误主要在这里
  // 如果超时重试为3,第一次超时了,马上又发起了一次新的请求,但是这里错误使用了超时的退出
  // 具体看上面
  select {
  case res := <-done:
   return res.data, res.err
  case <-time.After(time.Duration(p.timeout) * time.Millisecond):
  }
 }
 return nil, ecode.TimeoutErr
}

错误的原因

1、超时重试,之后过了一段时间没有拿到结果就认为是超时了,但是http请求没有被关闭;

2、错误使用了http的超时,具体的做法要通过context或http.client去实现,见下文;

修改之后的代码

func doRequest(request *request) ([]byte, error) {
 var (
  req    *http.Request
  errReq error
 )
 if request.value != "null" {
  buf := strings.NewReader(request.value)
  req, errReq = http.NewRequest(request.method, request.url, buf)
  if errReq != nil {
   return nil, errReq
  }
 } else {
  req, errReq = http.NewRequest(request.method, request.url, nil)
  if errReq != nil {
   return nil, errReq
  }
 }

 // 这里通过http.Client设置超时时间
 client := http.Client{
  Timeout: time.Duration(request.ps.timeout) * time.Millisecond,
 }
 res, err := client.Do(req)
 ...
}

func asyncCall(f func(request *request) ([]byte, error), req *request) ([]byte, error) {
 p := req.ps
 // 重试的时候只有上一个http请求真的超时了,之后才会发起一次新的请求
 for i := 0; i < p.retry; i++ {
  // 发送HTTP请求
  res, err := f(req)
  // 判断超时
  if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
   continue
  }

  return res, err

 }
 return nil, ecode.TimeoutErr
}

服务设置超时

http.Server有两个设置超时的方法:

ReadTimeout
ReadTimeout的时间计算是从连接被接受(accept)到request body完全被读取(如果你不读取body,那么时间截止到读完header为止)

WriteTimeout
WriteTimeout的时间计算正常是从request header的读取结束开始,到response write结束为止 (也就是ServeHTTP方法的生命周期)

srv := &http.Server{  
    ReadTimeout: 5 * time.Second,
    WriteTimeout: 10 * time.Second,
}

 
srv.ListenAndServe()

net/http包还提供了TimeoutHandler返回了一个在给定的时间限制内运行的handler

func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler

第一个参数是Handler,第二个参数是time.Duration(超时时间),第三个参数是string类型,当到达超时时间后返回的信息

func handler(w http.ResponseWriter, r *http.Request) {
 time.Sleep(3 * time.Second)
 fmt.Println("测试超时")

 w.Write([]byte("hello world"))
}

func server() {
 srv := http.Server{
  Addr:         ":8081",
  WriteTimeout: 1 * time.Second,
  Handler:      http.TimeoutHandler(http.HandlerFunc(handler), 5*time.Second, "Timeout!\n"),
 }
 if err := srv.ListenAndServe(); err != nil {
  os.Exit(1)
 }
}

客户端设置超时

http.client
最简单的我们通过http.Client的Timeout字段,就可以实现客户端的超时控制

http.client超时是超时的高层实现,包含了从Dial到Response Body的整个请求流程。http.client的实现提供了一个结构体类型可以接受一个额外的time.Duration类型的Timeout属性。这个参数定义了从请求开始到响应消息体被完全接收的时间限制。

func httpClientTimeout() {
 c := &http.Client{
  Timeout: 3 * time.Second,
 }

 resp, err := c.Get("http://127.0.0.1:8081/test")
 fmt.Println(resp)
 fmt.Println(err)
}

context
net/http中的request实现了context,所以我们可以借助于context本身的超时机制,实现http中request的超时处理

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

 req, err := http.NewRequest("GET", "http://127.0.0.1:8081/test", nil)
 if err != nil {
  log.Fatal(err)
 }

 resp, err := http.DefaultClient.Do(req.WithContext(ctx))
 fmt.Println(resp)
 fmt.Println(err)
}

使用context的优点就是,当父context被取消时,子context就会层层退出。

http.Transport
通过Transport还可以进行一些更小维度的超时设置

  • net.Dialer.Timeout 限制建立TCP连接的时间
  • http.Transport.TLSHandshakeTimeout 限制 TLS握手的时间
  • http.Transport.ResponseHeaderTimeout 限制读取response header的时间
  • http.Transport.ExpectContinueTimeout 限制client在发送包含 Expect: 100-continue的header到收到继续发送body的response之间的时间等待。注意在1.6中设置这个值会禁用HTTP/2(DefaultTransport自1.6.2起是个特例)
func transportTimeout() {
 transport := &http.Transport{
  DialContext:           (&net.Dialer{}).DialContext,
  ResponseHeaderTimeout: 3 * time.Second,
 }

 c := http.Client{Transport: transport}

 resp, err := c.Get("http://127.0.0.1:8081/test")
 fmt.Println(resp)
 fmt.Println(err)
}

问题
如果在客户端在超时的临界点,触发了超时机制,这时候服务端刚好也接收到了,http的请求

这种服务端还是可以拿到请求的数据,所以对于超时时间的设置我们需要根据实际情况进行权衡,同时我们要考虑接口的幂等性。

总结

1、所有的超时实现都是基于Deadline,Deadline是一个时间的绝对值,一旦设置他们永久生效,不管此时连接是否被使用和怎么用,所以需要每手动设置,所以如果想使用SetDeadline建立超时机制,需要每次在Read/Write操作之前调用它。

2、使用context进行超时控制的好处就是,当父context超时的时候,子context就会层层退出。

参考

【[译]Go net/http 超时机制完全手册】
【Go 语言 HTTP 请求超时入门】
【使用 timeout、deadline 和 context 取消参数使 Go net/http 服务更灵活】

到此这篇关于go语言中http超时引发的事故解决的文章就介绍到这了,更多相关go语言 http超时内容请搜索三水点靠木以前的文章或继续浏览下面的相关文章希望大家以后多多支持三水点靠木!

Golang 相关文章推荐
Go语言操作数据库及其常规操作的示例代码
Apr 21 Golang
Go语言带缓冲的通道实现
Apr 26 Golang
golang 如何用反射reflect操作结构体
Apr 28 Golang
golang slice元素去重操作
Apr 30 Golang
Go 自定义package包设置与导入操作
May 06 Golang
Go中的条件语句Switch示例详解
Aug 23 Golang
golang实现浏览器导出excel文件功能
Mar 25 Golang
Golang流模式之grpc的四种数据流
Apr 13 Golang
golang语言指针操作
Apr 14 Golang
Golang 字符串的常见操作
Apr 19 Golang
Golang解析JSON对象
Apr 30 Golang
Golang二维数组的使用方式
May 28 #Golang
Golang标准库syscall详解(什么是系统调用)
May 25 #Golang
go 实现简易端口扫描的示例
May 22 #Golang
go xorm框架的使用
May 22 #Golang
Golang实现AES对称加密的过程详解
May 20 #Golang
go语言基础 seek光标位置os包的使用
May 09 #Golang
Golang 实现获取当前函数名称和文件行号等操作
May 08 #Golang
You might like
使用Linux五年积累的一些经验技巧
2013/06/20 PHP
php版阿里云OSS图片上传类详解
2016/12/01 PHP
OAuth认证协议中的HMACSHA1加密算法(实例)
2017/10/25 PHP
PHP7扩展开发之hello word实现方法详解
2018/01/15 PHP
PHP程序员学习使用Swoole的理由
2018/06/24 PHP
laravel admin实现分类树/模型树的示例代码
2020/06/10 PHP
基于Css3和JQuery实现打字机效果
2015/08/11 Javascript
js简单网速测试方法完整实例
2015/12/15 Javascript
JavaScript拖拽、碰撞、重力及弹性运动实例分析
2016/01/08 Javascript
原生javascript实现分享到朋友圈功能 支持ios和android
2016/05/11 Javascript
怎么限制input的text里输入的值只能是数字(正则、js)
2016/05/16 Javascript
canvas绘图不清晰的解决方案
2017/02/28 Javascript
Vue.js常用指令之循环使用v-for指令教程
2017/06/27 Javascript
浅谈angular4 ng-content 中隐藏的内容
2017/08/18 Javascript
vue给input file绑定函数获取当前上传的对象完美实现方法
2017/12/15 Javascript
从Node.js事件触发器到Vue自定义事件的深入讲解
2020/06/26 Javascript
Python学习笔记之常用函数及说明
2014/05/23 Python
Python实现将绝对URL替换成相对URL的方法
2015/06/28 Python
python生成式的send()方法(详解)
2017/05/08 Python
Python3实现的画图及加载图片动画效果示例
2018/01/19 Python
对Python3中的print函数以及与python2的对比分析
2018/05/02 Python
python requests 测试代理ip是否生效
2018/07/25 Python
解决python os.mkdir创建目录失败的问题
2018/10/16 Python
三个python爬虫项目实例代码
2019/12/28 Python
Python代码注释规范代码实例解析
2020/08/14 Python
基本款天堂:Everlane
2017/05/13 全球购物
荷兰街头时尚之家:Funkie House
2019/03/18 全球购物
土耳其风格手工珠宝:Ottoman Hands
2019/07/26 全球购物
优秀毕业生自我鉴定
2014/01/19 职场文书
建议书怎么写
2014/03/12 职场文书
财务部副经理岗位职责范本
2014/06/17 职场文书
股东合作协议书
2014/09/12 职场文书
2015年市场营销工作总结
2015/07/23 职场文书
高中同学会致辞
2015/08/01 职场文书
酒店员工管理制度
2015/08/05 职场文书
JS前端使用canvas实现物体的点选示例
2022/08/05 Javascript