go自带的database/sql拥有连接池的能力，可以通过SetMaxOpenConns配置最大的连接数，当超过最大连接时，database/sql是如何处理的呢？
答案是将请求放入等待队列并阻塞，当有连接释放时被唤醒，将释放的连接给它。
申请连接
申请连接的流程：
- 首先检查连接池是否有空闲的连接，若有，则返回该连接；
检查是否超过最大连接数：
- 若超过最大连接，则将该请求放入等待队列；
- 否则，新建一个连接对象返回；
// conn returns a newly-opened or cached *driverConn.
func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn, error) {
......
//先检查连接池是否有空闲的连接，若有，则返回该conn
......
//如果超过最大连接数，将该连接请求放入等待队列中并阻塞
if db.maxOpen > 0 && db.numOpen >= db.maxOpen {
req := make(chan connRequest, 1)
reqKey := db.nextRequestKeyLocked()
db.connRequests[reqKey] = req
db.waitCount++
select {
case <-ctx.Done():
......
case ret, ok := <-req:
......
return ret.conn, ret.err
}
}
//新建一个连接对象，返回
......
}重点关注超过最大连接数的行为，将连接请求放入等待队列connRequests：map[unit64]chan connRequest类型，key是unit64，value是chan connRequest，请求放入map的逻辑：
req := make(chan connRequest, 1)
reqKey := db.nextRequestKeyLocked()
db.connRequests[reqKey] = req
db.waitCount++
//reqKey是递增的整数值
func (db *DB) nextRequestKeyLocked() uint64 {
next := db.nextRequest
db.nextRequest++
return next
}除了将request加入map，还用select将请求阻塞：
// Timeout the connection request with the context.
select {
//cxt.Done()
case <-ctx.Done():
......
//req是chann connRequest，也就是channel上有数据，就返回该连接
case ret, ok := <-req:
return ret.conn, ret.err
}这个阻塞的select，等待req channel上有数据。
当有连接释放的时候，会向channel上放数据，这里就不再阻塞，可以走下去了。
释放连接
入口函数是releaseConn：
func (dc *driverConn) releaseConn(err error) {
dc.db.putConn(dc, err, true)
}
func (db *DB) putConn(dc *driverConn, err error, resetSession bool) {
......
dc.inUse = false
added := db.putConnDBLocked(dc, nil) //释放连接
db.mu.Unlock()
// 如果没有加到了空闲列表中，则关闭dc
if !added {
dc.Close()
}
}释放连接的逻辑在db.putConnDBLocked中：
- 首先检查connection等待队列中，是否有阻塞的请求；
- 若有，则将该connection给它，向channel中发数据，阻塞的连接请求就可以拿到连接；
- 否则，将连接放至freeConn连接池中；
func (db *DB) putConnDBLocked(dc *driverConn, err error) bool {
//等待队列中，有阻塞等待的请求
if c := len(db.connRequests); c > 0 {
var req chan connRequest
var reqKey uint64
for reqKey, req = range db.connRequests {
break
}
delete(db.connRequests, reqKey) //删除该请求
//给该请求一个数据，也就是向channel上放数据，这样的话，阻塞的请求就可以进行下去了
req <- connRequest{
conn: dc,
err: err,
}
return true
} else if err == nil && !db.closed { //放入空闲连接池
if db.maxIdleConnsLocked() > len(db.freeConn) {
db.freeConn = append(db.freeConn, dc)
db.startCleanerLocked()
return true
}
db.maxIdleClosed++
}
......
}