记go中一次http超时引发的事故
<ul><li>记一次http超时引发的事故
<ul>
<li>前言</li>
<li>分析下具体的代码实现</li>
<li>服务设置超时</li>
<li>客户端设置超时
<ul>
<li>http.client</li>
<li>context</li>
<li>http.Transport</li>
</ul>
</li>
<li>问题</li>
<li>总结</li>
<li>参考</li>
</ul>
</li>
</ul>
<h2 id="记一次http超时引发的事故">记一次http超时引发的事故</h2>
<h3 id="前言">前言</h3>
<p>我们使用的是golang标准库的<code>http client</code>，对于一些http请求，我们在处理的时候，会考虑加上超时时间，防止http请求一直在请求，导致业务长时间阻塞等待。</p>
<p>最近同事写了一个超时的组件，这几天访问量上来了，网络也出现了波动，造成了接口在报错超时的情况下，还是出现了请求结果的成功。</p>
<h3 id="分析下具体的代码实现">分析下具体的代码实现</h3>
<pre><code class="language-go">type request struct {
method string
url string
valuestring
ps *params
}
type params struct {
timeout int //超时时间
retry int //重试次数
headers mapstring
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
errerror
}
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
}
</code></pre>
<p>错误的原因</p>
<p>1、超时重试，之后过了一段时间没有拿到结果就认为是超时了，但是http请求没有被关闭；</p>
<p>2、错误使用了<code>http</code>的超时，具体的做法要通过<code>context</code>或<code>http.client</code>去实现，见下文；</p>
<p>修改之后的代码</p>
<pre><code class="language-go">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
}
</code></pre>
<h3 id="服务设置超时">服务设置超时</h3>
<p><code>http.Server</code>有两个设置超时的方法:</p>
<ul>
<li>ReadTimeout</li>
</ul>
<p><code>ReadTimeout</code>的时间计算是从连接被接受(accept)到<code>request body</code>完全被读取(如果你不读取body，那么时间截止到读完header为止)</p>
<ul>
<li>WriteTimeout</li>
</ul>
<p><code>WriteTimeout</code>的时间计算正常是从<code>request header</code>的读取结束开始，到<code>response write</code>结束为止 (也就是ServeHTTP方法的生命周期)</p>
<pre><code class="language-go">srv := &http.Server{
ReadTimeout: 5 * time.Second,
WriteTimeout: 10 * time.Second,
}
srv.ListenAndServe()
</code></pre>
<p><code>net/http</code>包还提供了<code>TimeoutHandler</code>返回了一个在给定的时间限制内运行的<code>handler</code></p>
<pre><code class="language-go">func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler
</code></pre>
<p>第一个参数是<code>Handler</code>，第二个参数是<code>time.Duration</code>（超时时间），第三个参数是<code>string</code>类型，当到达超时时间后返回的信息</p>
<pre><code class="language-go">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)
}
}
</code></pre>
<h3 id="客户端设置超时">客户端设置超时</h3>
<h4 id="httpclient">http.client</h4>
<p>最简单的我们通过<code>http.Client</code>的<code>Timeout</code>字段，就可以实现客户端的超时控制</p>
<p><code>http.client</code>超时是超时的高层实现，包含了从<code>Dial</code>到<code>Response Body</code>的整个请求流程。<code>http.client</code>的实现提供了一个结构体类型可以接受一个额外的<code>time.Duration</code>类型的<code>Timeout</code>属性。这个参数定义了从请求开始到响应消息体被完全接收的时间限制。</p>
<pre><code class="language-go">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)
}
</code></pre>
<h4 id="context">context</h4>
<p><code>net/http</code>中的<code>request</code>实现了<code>context</code>,所以我们可以借助于context本身的超时机制，实现<code>http</code>中<code>request</code>的超时处理</p>
<pre><code class="language-go">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)
}
</code></pre>
<p>使用<code>context</code>的优点就是，当父<code>context</code>被取消时，子<code>context</code>就会层层退出。</p>
<h4 id="httptransport">http.Transport</h4>
<p>通过<code>Transport</code>还可以进行一些更小维度的超时设置</p>
<ul>
<li>
<p>net.Dialer.Timeout 限制建立TCP连接的时间</p>
</li>
<li>
<p>http.Transport.TLSHandshakeTimeout 限制 TLS握手的时间</p>
</li>
<li>
<p>http.Transport.ResponseHeaderTimeout 限制读取response header的时间</p>
</li>
<li>
<p>http.Transport.ExpectContinueTimeout 限制client在发送包含 Expect: 100-continue的header到收到继续发送body的response之间的时间等待。注意在1.6中设置这个值会禁用HTTP/2(DefaultTransport自1.6.2起是个特例)</p>
</li>
</ul>
<pre><code class="language-go">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)
}
</code></pre>
<h3 id="问题">问题</h3>
<p><strong>如果在客户端在超时的临界点，触发了超时机制，这时候服务端刚好也接收到了，http的请求</strong></p>
<p>这种服务端还是可以拿到请求的数据，所以对于超时时间的设置我们需要根据实际情况进行权衡，同时我们要考虑接口的幂等性。</p>
<h3 id="总结">总结</h3>
<p>1、所有的超时实现都是基于<code>Deadline</code>，<code>Deadline</code>是一个时间的绝对值，一旦设置他们永久生效，不管此时连接是否被使用和怎么用，所以需要每手动设置，所以如果想使用<code>SetDeadline</code>建立超时机制，需要每次在<code>Read/Write</code>操作之前调用它。</p>
<p>2、使用<code>context</code>进行超时控制的好处就是，当父<code>context</code>超时的时候，子<code>context</code>就会层层退出。</p>
<h3 id="参考">参考</h3>
<p>【[译]Go net/http 超时机制完全手册】https://colobu.com/2016/07/01/the-complete-guide-to-golang-net-http-timeouts/<br>
【Go 语言 HTTP 请求超时入门】https://studygolang.com/articles/14405<br>
【使用 timeout、deadline 和 context 取消参数使 Go net/http 服务更灵活】https://jishuin.proginn.com/p/763bfbd2fb6a</p><br><br>
来源：https://www.cnblogs.com/ricklz/p/14840205.html
頁:
[1]