golang mysql连接池原理_Golang 你一定要懂的连接池

问题引入

作为一名Golang开发者，线上环境遇到过好几次连接数暴增问题(mysql/redis/kafka等)。

纠其原因，Golang作为常驻进程，请求第三方服务或者资源完毕后，需要手动关闭连接，否则连接会一直存在。而很多时候，开发者不一定记得关闭这个连接。

这样是不是很麻烦？于是有了连接池。顾名思义，连接池就是管理连接的；我们从连接池获取连接，请求完毕后再将连接还给连接池；连接池帮我们做了连接的建立、复用以及回收工作。

在设计与实现连接池时，我们通常需要考虑以下几个问题：连接池的连接数目是否有限制，最大可以建立多少个连接？

当连接长时间没有使用，需要回收该连接吗？

业务请求需要获取连接时，此时若连接池无空闲连接且无法新建连接，业务需要排队等待吗？

排队的话又存在另外的问题，队列长度有无限制，排队时间呢？

Golang连接池实现原理

我们以Golang HTTP连接池为例，分析连接池的实现原理。

结构体Transport

Transport结构定义如下：type Transport struct {

//操作空闲连接需要获取锁

idleMu sync.Mutex

//空闲连接池，key为协议目标地址等组合

idleConn map[connectMethodKey][]*persistConn // most recently used at end

//等待空闲连接的队列，基于切片实现，队列大小无限制

idleConnWait map[connectMethodKey]wantConnQueue // waiting getConns

//排队等待建立连接需要获取锁

connsPerHostMu sync.Mutex

//每个host建立的连接数

connsPerHost map[connectMethodKey]int

//等待建立连接的队列，同样基于切片实现，队列大小无限制

connsPerHostWait map[connectMethodKey]wantConnQueue // waiting getConns

//最大空闲连接数

MaxIdleConns int

//每个目标host最大空闲连接数；默认为2(注意默认值)

MaxIdleConnsPerHost int

//每个host可建立的最大连接数

MaxConnsPerHost int

//连接多少时间没有使用则被关闭

IdleConnTimeout time.Duration

//禁用长连接，使用短连接

DisableKeepAlives bool

}

可以看到，连接护着队列，都是一个map结构，而key为协议目标地址等组合，即同一种协议与同一个目标host可建立的连接或者空闲连接是有限制的。

需要特别注意的是，MaxIdleConnsPerHost默认等于2，即与目标主机最多只维护两个空闲连接。这会导致什么呢？

如果遇到突发流量，瞬间建立大量连接，但是回收连接时，由于最大空闲连接数的限制，该联机不能进入空闲连接池，只能直接关闭。结果是，一直新建大量连接，又关闭大量连，业务机器的TIME_WAIT连接数随之突增。

线上有些业务架构是这样的：客户端 ===> LVS ===> Nginx ===> 服务。LVS负载均衡方案采用DR模式，LVS与Nginx配置统一VIP。此时在客户端看来，只有一个IP地址，只有一个Host。上述问题更为明显。

最后，Transport也提供了配置DisableKeepAlives，禁用长连接，使用短连接访问第三方资源或者服务。

连接获取与回收

Transport结构提供下面两个方法实现连接的获取与回收操作。func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error) {}

func (t *Transport) tryPutIdleConn(pconn *persistConn) error {}

连接的获取主要分为两步走：1)尝试获取空闲连接；2)尝试新建连接：//getConn方法内部实现

if delivered := t.queueForIdleConn(w); delivered {

return pc, nil

}

t.queueForDial(w)

当然，可能获取不到连接而需要排队，此时怎么办呢？当前会阻塞当前协程了，直到获取连接为止，或者httpclient超时取消请求：select {

case

return w.pc, w.err

//超时被取消

case

return nil, errRequestCanceledConn

……

}

var errRequestCanceledConn = errors.New("net/http: request canceled while waiting for connection") // TODO: unify?

排队等待空闲连接的逻辑如下：func (t *Transport) queueForIdleConn(w *wantConn) (delivered bool) {

//如果配置了空闲超时时间，获取到连接需要检测，超时则关闭连接

if t.IdleConnTimeout > 0 {

oldTime = time.Now().Add(-t.IdleConnTimeout)

}

if list, ok := t.idleConn[w.key]; ok {

for len(list) > 0 && !stop {

pconn := list[len(list)-1]

tooOld := !oldTime.IsZero() && pconn.idleAt.Round(0).Before(oldTime)

//超时了，关闭连接

if tooOld {

go pconn.closeConnIfStillIdle()

}

//分发连接到wantConn

delivered = w.tryDeliver(pconn, nil)

}

}

//排队等待空闲连接

q := t.idleConnWait[w.key]

q.pushBack(w)

t.idleConnWait[w.key] = q

}

排队等待新建连接的逻辑如下：func (t *Transport) queueForDial(w *wantConn) {

//如果没有限制最大连接数，直接建立连接

if t.MaxConnsPerHost <= 0 {

go t.dialConnFor(w)

return

}

//如果没超过连接数限制，直接建立连接

if n := t.connsPerHost[w.key]; n < t.MaxConnsPerHost {

go t.dialConnFor(w)

return

}

//排队等待连接建立

q := t.connsPerHostWait[w.key]

q.pushBack(w)

t.connsPerHostWait[w.key] = q

}

连接建立完成后，同样会调用tryDeliver分发连接到wantConn，同时关闭通道w.ready，这样主协程纠接触阻塞了。func (w *wantConn) tryDeliver(pc *persistConn, err error) bool {

w.pc = pc

close(w.ready)

}

请求处理完成后，通过tryPutIdleConn将连接放回连接池；这时候如果存在等待空闲连接的协程，则需要分发复用该连接。另外，在回收连接时，还需要校验空闲连接数目是否超过限制：func (t *Transport) tryPutIdleConn(pconn *persistConn) error {

//禁用长连接；或者最大空闲连接数不合法

if t.DisableKeepAlives || t.MaxIdleConnsPerHost < 0 {

return errKeepAlivesDisabled

}

if q, ok := t.idleConnWait[key]; ok {

//如果等待队列不为空，分发连接

for q.len() > 0 {

w := q.popFront()

if w.tryDeliver(pconn, nil) {

done = true

break

}

}

}

//空闲连接数目超过限制，默认为DefaultMaxIdleConnsPerHost=2

idles := t.idleConn[key]

if len(idles) >= t.maxIdleConnsPerHost() {

return errTooManyIdleHost

}

}

空闲连接超时关闭

Golang HTTP连接池如何实现空闲连接的超时关闭逻辑呢？从上述queueForIdleConn逻辑可以看到，每次在获取到空闲连接时，都会检测是否已经超时，超时则关闭连接。

那如果没有业务请求到达，一直不需要获取连接，空闲连接就不会超时关闭吗？其实在将空闲连接添加到连接池时，Golang同时还设置了定时器，定时器到期后，自然会关闭该连接。pconn.idleTimer = time.AfterFunc(t.IdleConnTimeout, pconn.closeConnIfStillIdle)

排队队列怎么实现

怎么实现队列模型呢？很简单，可以基于切片：queue []*wantConn

//入队

queue = append(queue, w)

//出队

v := queue[0]

queue[0] = nil

queue = queue[1:]

这样有什么问题吗？随着频繁的入队与出队操作，切片queue的底层数组，会有大量空间无法复用而造成浪费。除非该切片执行了扩容操作。

Golang在实现队列时，使用了两个切片head和tail；head切片用于出队操作，tail切片用于入队操作；出队时，如果head切片为空，则交换head与tail。通过这种方式，Golang实现了底层数组空间的复用。func (q *wantConnQueue) pushBack(w *wantConn) {

q.tail = append(q.tail, w)

}

func (q *wantConnQueue) popFront() *wantConn {

if q.headPos >= len(q.head) {

if len(q.tail) == 0 {

return nil

}

// Pick up tail as new head, clear tail.

q.head, q.headPos, q.tail = q.tail, 0, q.head[:0]

}

w := q.head[q.headPos]

q.head[q.headPos] = nil

q.headPos++

return w

}

有疑问加站长微信联系(非本文作者)