问题引入
作为一名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 <-w.ready:
return w.pc, w.err
//超时被取消
case <-req.cancel:
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
}