• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    go语言中http超时引发的事故解决

    前言

    我们使用的是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还可以进行一些更小维度的超时设置

    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超时内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    您可能感兴趣的文章:
    • 解决Goland中利用HTTPClient发送请求超时返回EOF错误DEBUG
    • Go中http超时问题的排查及解决方法
    • golang http 连接超时和传输超时的例子
    上一篇:Windows+Linux系统下Go语言环境安装配置过程
    下一篇:golang特有程序结构入门教程
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

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