golang长连接的误用

误用一:忘记读取响应的body

由于忘记读取响应的body导致创建大量处于TIME_WAIT状态的连接(同时产生大量处于transport.go的readLoop和writeLoop的协程)

在linux下运行下面的代码:

package mainimport ("fmt""html""log""net""net/http""time"
)func startWebserver() {http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))})go http.ListenAndServe(":8080", nil)}func startLoadTest() {count := 0for {resp, err := http.Get("http://localhost:8080/")if err != nil {panic(fmt.Sprintf("Got error: %v", err))}resp.Body.Close()log.Printf("Finished GET request #%v", count)count += 1}}func main() {startWebserver()startLoadTest()}

在程序运行时另外开一个终端运行下面的命令:

netstat -n | grep -i 8080 | grep -i time_wait | wc -l

你会看到TIME_WAIT数量在持续增长

root@myhost:/# netstat -n | grep -i 8080 | grep -i time_wait | wc -l
166
root@myhost:/# netstat -n | grep -i 8080 | grep -i time_wait | wc -l
231
root@myhost:/# netstat -n | grep -i 8080 | grep -i time_wait | wc -l
293
root@myhost:/# netstat -n | grep -i 8080 | grep -i time_wait | wc -l
349

解决办法: 读取响应的body
更改startLoadTest()函数,添加下面的代码:

func startLoadTest() {for {...if err != nil {panic(fmt.Sprintf("Got error: %v", err))}io.Copy(ioutil.Discard, resp.Body)  // <-- add this lineresp.Body.Close()...}}

现在再次运行netstat -n | grep -i 8080 | grep -i time_wait | wc -l,你会发现TIME_WAIT状态的连接数为0

误用二:空闲连接最大数量设置太小,实际连接数量超过连接池的限制

连接的数量超过连接池的限制导致出现大量TIME_WAIT状态的连接

这种情况时由于持续超过连接池导致许多短连接被打开。
请看下面的代码:

package mainimport ("fmt""html""io""io/ioutil""log""net/http""time"
)func startWebserver() {http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {time.Sleep(time.Millisecond * 50)fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))})go http.ListenAndServe(":8080", nil)}func startLoadTest() {count := 0for {resp, err := http.Get("http://localhost:8080/")if err != nil {panic(fmt.Sprintf("Got error: %v", err))}io.Copy(ioutil.Discard, resp.Body)resp.Body.Close()log.Printf("Finished GET request #%v", count)count += 1}}func main() {// start a webserver in a goroutinestartWebserver()for i := 0; i < 100; i++ {go startLoadTest()}time.Sleep(time.Second * 2400)}

在另外一个终端运行netstat,尽管响应已经被读取,TIME_WAIT的连接数还是持续增加

root@ myhost:/# netstat -n | grep -i 8080 | grep -i time_wait | wc -l
166
root@ myhost:/# netstat -n | grep -i 8080 | grep -i time_wait | wc -l
231
root@ myhost:/# netstat -n | grep -i 8080 | grep -i time_wait | wc -l
293
root@ myhost:/# netstat -n | grep -i 8080 | grep -i time_wait | wc -l
349

什么是TIME_WAIT状态呢?

就是当我们创建大量短连接时,linux内核的网络栈保持连接处于TIME_WAIT状态,以避免某些问题。
例如:避免来自一个关闭的连接延迟的包被后来的连接所接收。并发连接被用地址,端口,序列号等其他机制所隔离开。

为什么这么多的TIME_WAIT端口?

默认情况下,Golang的http client会做连接池。他会在完成一个连接请求后把连接加到一个空闲的连接池中。如果你想在这个连接空闲超时前发起另外一个http请求,它会复用现有的连接。
这会把总socket连接数保持的低一些,直到连接池满。如果连接池满了,它会创建一个新的连接来发起http请求。
那这个连接池有多大呢?看看transport.go:

var DefaultTransport RoundTripper = &Transport{... MaxIdleConns:          100,IdleConnTimeout:       90 * time.Second,... 
}// DefaultMaxIdleConnsPerHost is the default value of Transport's
// MaxIdleConnsPerHost.
const DefaultMaxIdleConnsPerHost = 2
  • MaxIdleConns:100 设置连接池的大小为100个连接
  • IdleConnTimeOut被设置为90秒,意味着一个连接在连接池里最多保持90秒的空闲时间,超过这个时间将会被移除并关闭
  • DefaultMaxIdleConnsPerHost = 2 这个设置意思时尽管整个连接池是100个连接,但是每个host只有2个。

上面的例子中有100个gooutine尝试并发的对同一个主机发起http请求,但是连接池只能存放两个连接。所以,第一轮完成请求时,2个连接保持打开状态。但是剩下的98个连接将会被关闭并进入TIME_WAIT状态。

因为这在一个循环中出现,所以会很快就积累上成千上万的TIME_WAIT状态的连接。最终,会耗尽主机的所有可用端口,从而导致无法打开新的连接。

修复: 增加http client的连接池大小

import (.. 
)var myClient *http.Clientfunc startWebserver() {... same code as before}func startLoadTest() {... for {resp, err := myClient.Get("http://localhost:8080/")  // <-- use a custom client with custom *http.Transport... everything else is the same}}func main() {// Customize the Transport to have larger connection pooldefaultRoundTripper := http.DefaultTransportdefaultTransportPointer, ok := defaultRoundTripper.(*http.Transport)if !ok {panic(fmt.Sprintf("defaultRoundTripper not an *http.Transport"))}defaultTransport := *defaultTransportPointer // dereference it to get a copy of the struct that the pointer points todefaultTransport.MaxIdleConns = 100defaultTransport.MaxIdleConnsPerHost = 100myClient = &http.Client{Transport: &defaultTransport}// start a webserver in a goroutinestartWebserver()for i := 0; i < 100; i++ {go startLoadTest()}time.Sleep(time.Second * 2400)}

当然,如果你的并发要求高,可以把连接池的数量改的更大些。
但是这样没有根本解决问题,因为go的http.Client在连接池被占满并且所有连接都在被使用的时候会创建一个新的连接。
具体可以看代码,http.Client处理请求的核心在用它的transport获取一个连接:

// roundTrip implements a RoundTripper over HTTP.
func (t *Transport) roundTrip(req *Request) (*Response, error) {//...省略部分代码// Get the cached or newly-created connection to either the// host (for http or https), the http proxy, or the http proxy// pre-CONNECTed to https server. In any case, we'll be ready// to send it requests.pconn, err := t.getConn(treq, cm)  //看这里if err != nil {t.setReqCanceler(req, nil)req.closeBody()return nil, err}var resp *Responseif pconn.alt != nil {// HTTP/2 path.t.setReqCanceler(req, nil) // not cancelable with CancelRequestresp, err = pconn.alt.RoundTrip(req)} else {resp, err = pconn.roundTrip(treq)}if err == nil {return resp, nil}//...省略部分代码}

getConn方法的实现核心如下:

// getConn dials and creates a new persistConn to the target as
// specified in the connectMethod. This includes doing a proxy CONNECT
// and/or setting up TLS.  If this doesn't return an error, the persistConn
// is ready to write requests to.
func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error) {req := treq.Requesttrace := treq.tracectx := req.Context()if trace != nil && trace.GetConn != nil {trace.GetConn(cm.addr())}w := &wantConn{cm:         cm,key:        cm.key(),ctx:        ctx,ready:      make(chan struct{}, 1),beforeDial: testHookPrePendingDial,afterDial:  testHookPostPendingDial,}defer func() {if err != nil {w.cancel(t, err)}}()// Queue for idle connection.if delivered := t.queueForIdleConn(w); delivered { //注意这一行代码,看函数名意思是在Idle连接队列里等待,如果执行成功就拿到一个连接,如果拿不到连接就跳过下面这部分代码pc := w.pc// Trace only for HTTP/1.// HTTP/2 calls trace.GotConn itself.if pc.alt == nil && trace != nil && trace.GotConn != nil {trace.GotConn(pc.gotIdleConnTrace(pc.idleAt))}// set request canceler to some non-nil function so we// can detect whether it was cleared between now and when// we enter roundTript.setReqCanceler(req, func(error) {})return pc, nil}cancelc := make(chan error, 1)t.setReqCanceler(req, func(err error) { cancelc <- err })// Queue for permission to dial.t.queueForDial(w) /拿不到连接就放入等待拨号的队列//...省略部分代码
}

我们再看queueForDial方法的实现:

// queueForDial queues w to wait for permission to begin dialing.
// Once w receives permission to dial, it will do so in a separate goroutine.
func (t *Transport) queueForDial(w *wantConn) {w.beforeDial()if t.MaxConnsPerHost <= 0 { //看这里,如果这个值小于等于0,就直接创建连接了,我们之前没有设置这个选项导致的go t.dialConnFor(w)return}t.connsPerHostMu.Lock()defer t.connsPerHostMu.Unlock()if n := t.connsPerHost[w.key]; n < t.MaxConnsPerHost {if t.connsPerHost == nil {t.connsPerHost = make(map[connectMethodKey]int)}t.connsPerHost[w.key] = n + 1go t.dialConnFor(w)return}if t.connsPerHostWait == nil {t.connsPerHostWait = make(map[connectMethodKey]wantConnQueue)}q := t.connsPerHostWait[w.key]q.cleanFront()q.pushBack(w)t.connsPerHostWait[w.key] = q
}

误用三:没有重用同一个长连接的http.Transport对象

我们的一个服务是用Go写的,在测试的时候发现几个小时之后它就会core掉,而且core的时候没有打出任何堆栈信息,简单分析后发现该服务中的几个HTTP服务的连接数不断增长,而我们的开发机的fd limit只有1024,当该服务所属进程的连接数增长到系统的fd limit的时候,它被操作系统杀掉了。。。

    HTTP Connection中连接未被释放的问题在https://groups.google.com/forum/#!topic/golang-nuts/wliZf2_LUag和https://groups.google.com/forum/#!topic/golang-nuts/tACF6RxZ4GQ都有提到。

    这个服务中,我们会定期向一个HTTP服务器发起POST请求,因为请求非常不频繁,所以想采用短连接的方式去做。请求代码大概长这样:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

func dialTimeout(network, addr string) (net.Conn, error) {

    return net.DialTimeout(network, addr, time.Second*POST_REMOTE_TIMEOUT)

}

 

func DoRequest(URL string) xx, error {

       transport := http.Transport{

                Dial:              dialTimeout,

        }

 

        client := http.Client{

                Transport: &transport,

        }

 

        content := RequestContent{}

        // fill content here

 

        postStr, err := json.Marshal(content)

        if err != nil {

                return nil, err

        }

 

        resp, err := client.Post(URL, "application/json", bytes.NewBuffer(postStr))

        if err != nil {

                return nil, err

        }

 

        defer resp.Body.Close()

        body, err := ioutil.ReadAll(resp.Body)

        if err != nil {

                return nil, err

        }

 

        // receive body, handle it

}

  运行这段代码一段时间后会发现,该进程下面有一堆ESTABLISHED状态的连接(用lsof -p pid查看某进程下的所有fd),因为每次DoRequest函数被调用后,都会新建一个TCP连接,如果对端不先关闭该连接(对端发FIN包)的话,我们这边即便是调用了resp.Body.Close()函数仍然不会改变这些处于ESTABLISHED状态的连接。为什么会这样呢?只有去源代码一探究竟了。

      Golang的net包中client.go, transport.go, response.go和request.go这几个文件中实现了HTTP Client。当应用层调用client.Do()函数后,transport层会首先找与该请求相关的已经缓存的连接(这个缓存是一个map,map的key是请求方法、请求地址和proxy地址,value是一个叫persistConn的连接描述结构),如果已经有可以复用的旧连接,就会在这个旧连接上发送和接受该HTTP请求,否则会新建一个TCP连接,然后在这个连接上读写数据。当client接受到整个响应后,如果应用层没有
调用response.Body.Close()函数,刚刚传输数据的persistConn就不会被加入到连接缓存中,这样如果您在下次发起HTTP请求的时候,就会重新建立TCP连接,重新分配persistConn结构,这是不调用response.Body.Close()的一个副作用。
      如果不调用response.Body.Close()还存在一个问题。如果请求完成后,对端关闭了连接(对端的HTTP服务器向我发送了FIN),如果这边不调用response.Body.Close(),那么可以看到与这个请求相关的TCP连接的状态一直处于CLOSE_WAIT状态(还记得么?CLOSE_WAIT是连接的半开半闭状态,它是收到对方的FIN并且我们也发送了ACK,但是本端还没有发送FIN到对端,如果本段不调用close关闭连接,那么连接将一直处于
CLOSE_WAIT状态,不会被系统回收)。

      调用了response.Body.Close()就万无一失了么?上面代码中也调用了body.Close()为什么还会有很多ESTABLISHED状态的连接呢?因为在函数DoRequest()的每次调用中,我们都会新创建transport和client结构,当HTTP请求完成并且接收到响应后,如果对端的HTTP服务器没有关闭连接,那么这个连接会一直处于ESTABLISHED状态。如何解呢?
有两个方法:
      第一个方法是用一个全局的client,函数DoRequest()中每次都只在这个全局client上发送数据。但是如果我就想用短连接呢?用方法二。
      第二个方法是在transport分配时将它的DisableKeepAlives参数置为true,此时发送的请求头里会包含Connection: close,像下面这样:

1

2

3

4

5

6

7

8

9

10

// ...

transport := http.Transport{

        Dial:              dialTimeout,

        DisableKeepAlives: true,

}

 

client := http.Client{

        Transport: &transport,

}

// ...

  从transport.go:L908可以看到,当应用层调用resp.Body.Close()时,如果DisableKeepAlives被开启,那么transport自动关闭本端连接。而不将它加入到连接缓存中。

    补充一下,在dialTimeout函数中disable tcp连接的keepalive选项是不可行的,它只是设置TCP连接的选项,不会影响到transport中对连接的控制。

1

2

3

4

5

6

7

8

9

10

11

func dialTimeout(network, addr string) (net.Conn, error) {

        conn, err := net.DialTimeout(network, addr, time.Second*POST_REMOTE_TIMEOUT)

    if err != nil {

        return conn, err

    }

 

    tcp_conn := conn.(*net.TCPConn)                                                                                                 

    tcp_conn.SetKeepAlive(false)                                           

    return tcp_conn, err

}

--end--

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/pingmian/48863.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

第一弹:基于ABAP OLE技术实现对服务器文件进行读写操作

前言 最近遇到这样一个需求&#xff0c;需要对BW服务器上的文件进行下载的同时写入每个用户相对应的数据。之前的服务器模版是一个死模版&#xff0c;对于这样的要求&#xff0c;我就想到了OLE技术&#xff0c;那么什么是OLE技术呢&#xff1f; 一、什么是OLE技术&#xff1f…

Python 全栈体系【三阶】(三)

第一章 Django 七、静态文件 1. 概述 静态文件是指在WEB应用中的图像文件、CSS文件、Javascript文件。 2. 静态文件的配置 settings.py中关于静态文件的配置如下&#xff1a; STATICFILES_DIRS [BASE_DIR , static, ]STATIC_URL /static/其中&#xff1a; STATICFILES…

微服务架构下Mojo模型的创新应用:细粒度服务与智能优化

微服务架构下Mojo模型的创新应用&#xff1a;细粒度服务与智能优化 在当今快速发展的云计算和大数据时代&#xff0c;微服务架构以其灵活性、可扩展性和易于维护的特点&#xff0c;成为软件开发的主流趋势。Mojo模型&#xff0c;作为机器学习领域中的一种技术&#xff0c;通过…

C++——模板初阶 | STL简介

P. S.&#xff1a;以下代码均在VS2019环境下测试&#xff0c;不代表所有编译器均可通过。 P. S.&#xff1a;测试代码均未展示头文件stdio.h的声明&#xff0c;使用时请自行添加。 博主主页&#xff1a;Yan. yan.                        …

便携气象站:科技助力气象观测

在科技飞速发展的今天&#xff0c;便携气象站以其轻便、高效、全面的特点&#xff0c;正逐渐改变着气象观测的传统模式。这款小巧而强大的设备&#xff0c;不仅为气象学研究和气象灾害预警提供了有力支持&#xff0c;更为户外活动、农业生产等领域带来了诸多便利。 便携气象站是…

vscode anaconda jupyternotebook R Python配置

vscode anaconda jupyternotebook R Python配置 anaconda 官网下载安装vscode官网下载安装、jupyternotebook设置vscode基于python运行jupyternotebook其中python设置的是本地环境vscode基于r运行jupyternotebook4. 4.1下载R&#xff0c;可更改R工作目录 4.2 vscode的R扩展可以…

Redis+Lua脚本+AOP+反射+自定义注解,打造我司内部基础架构限流组件

定义注解 Retention(RetentionPolicy.RUNTIME) Target({ElementType.METHOD}) Documented public interface RedisLimitAnnotation {/*** 资源的key,唯一* 作用&#xff1a;不同的接口&#xff0c;不同的流量控制*/String key() default "";/*** 最多的访问限制次数…

算法日记day 17(二叉树的最大、最小深度)

一、二叉树的最大深度 题目&#xff1a; 给定一个二叉树 root &#xff0c;返回其最大深度。 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。 示例 1&#xff1a; 输入&#xff1a;root [3,9,20,null,null,15,7] 输出&#xff1a;3示例 2&#xff1…

STM32智能机器人控制系统教程

目录 引言环境准备智能机器人控制系统基础代码实现&#xff1a;实现智能机器人控制系统 4.1 数据采集模块 4.2 数据处理与控制模块 4.3 通信与导航系统实现 4.4 用户界面与数据可视化应用场景&#xff1a;机器人控制与优化问题解决方案与优化收尾与总结 1. 引言 智能机器人控…

qt中charts图表的使用方法

折线图 #include "widget.h" #include "ui_widget.h" #include <QtCharts/QChart> #include <QtCharts/QChartView> #include <QtCharts/QLineSeries> #include<QVBoxLayout>Widget::Widget(QWidget *parent): QWidget(parent), …

JS设计模式(六)装饰器模式

注释很详细&#xff0c;直接上代码 特色和用途&#xff1a; 扩展性&#xff1a;装饰器模式通过一种对客户端透明的方式来扩展对象的功能&#xff0c;而无需修改现有代码。这使得你可以逐步添加或修改功能&#xff0c;而不会影响到已有的代码。简化代码&#xff1a;装饰器模式避…

Windows图形界面(GUI)-MFC-C/C++ - MFC项目工程框架解析

公开视频 -> 链接点击跳转公开课程博客首页 -> e​​​​​​链接点击跳转博客主页 目录 MFC项目 项目选择 配置安装 程序引导 MFC框架 环境设置 程序框架 代码编写 MFC解析 程序入口 执行流程 代码结构 应用程序类 窗口框架类 消息处理 消息类型 消息…

异步TCP服务器;异步TCP客户端

目录 1. 异步TCP服务器 2. 异步TCP客户端 3. 其他模块的使用 在Python中,使用os, asyncio, typing, socket, 和 random等模块可以实现很多功能,比如异步网络通信、文件操作、随机数生成等。下面,我将基于这些模块给出一个简单的异步TCP客户端和服务器示例,同时解释这些模…

ML.Net 学习之使用经过训练的模型进行预测

什么是ML.Net&#xff1a;&#xff08;学习文档上摘的一段&#xff1a;ML.NET 文档 - 教程和 API 参考 | Microsoft Learn 【学习入口】&#xff09; 它使你能够在联机或脱机场景中将机器学习添加到 .NET 应用程序中。 借助此功能&#xff0c;可以使用应用程序的可用数据进行自…

【Go程序】爬虫获取豆瓣Top250

之前在网上下载了一个minigame的开源项目&#xff0c;就是电影日历。里面有一项使用了豆瓣的API&#xff0c;获取豆瓣的Top250的电影。但是由于豆瓣的OpenAPI改版了&#xff0c;又不好申请到OpenAPI的资格&#xff0c;想想也不是什么非法的事情&#xff0c;就稍微搞几部电影名字…

Mojo模型魔法:动态定制特征转换的艺术

标题&#xff1a;Mojo模型魔法&#xff1a;动态定制特征转换的艺术 在机器学习领域&#xff0c;模型的灵活性和可扩展性是至关重要的。Mojo模型&#xff08;Model-as-a-Service&#xff09;提供了一种将机器学习模型部署为服务的方式&#xff0c;允许开发者和数据科学家轻松地…

一个简单好用安全的开源交互审计系统,支持SSH,Telnet,Kubernetes协议(带私活)

前言 在当今的企业网络环境中&#xff0c;远程访问和交互审计成为了保障网络安-全的重要组成部分。然而&#xff0c;现有的解-决方案往往存在一些痛点&#xff0c;如复杂的配置、有限的协议支持、以及审计功能的不足。这些问题不仅增加了IT管理员的负担&#xff0c;也为企业的…

【大数据专题】Flink题库

1 . 简述什么是Apache Flink &#xff1f; Apache Flink 是一个开源的基于流的有状态计算框架。它是分布式地执行的&#xff0c;具备低延迟、高吞吐的优秀性能&#xff0c;并且非常擅长处理有状态的复杂计算逻辑场景 2 . 简述Flink 的核心概念 &#xff1f; Flink 的核心概念…

基于R语言复杂数据回归与混合效应模型【多水平/分层/嵌套】技术与代码

回归分析是科学研究特别是生态学领域科学研究和数据分析十分重要的统计工具&#xff0c;可以回答众多科学问题&#xff0c;如环境因素对物种、种群、群落及生态系统或气候变化的影响&#xff1b;物种属性和系统发育对物种分布&#xff08;多度&#xff09;的影响等。纵观涉及数…

HarmonyOS NEXT零基础入门到实战-第四部分

自定义组件: 概念: 由框架直接提供的称为 系统组件&#xff0c; 由开发者定义的称为 自定义组件。 源代码&#xff1a; Component struct MyCom { build() { Column() { Text(我是一个自定义组件) } } } Component struct MyHeader { build() { Row(…