Golang连接池的几种实现案例小结

type Pool struct {
 m sync.Mutex // 保证多个goroutine访问时候，closed的线程安全
 res chan io.Closer //连接存储的chan
 factory func() (io.Closer,error) //新建连接的工厂方法
 closed bool //连接池关闭标志
}

func New(fn func() (io.Closer, error), size uint) (*Pool, error) {
 if size <= 0 {
 return nil, errors.New("size的值太小了。")
 }
 return &Pool{
 factory: fn,
 res:  make(chan io.Closer, size),
 }, nil
}

//从资源池里获取一个资源
func (p *Pool) Acquire() (io.Closer,error) {
 select {
 case r,ok := <-p.res:
 log.Println("Acquire:共享资源")
 if !ok {
 return nil,ErrPoolClosed
 }
 return r,nil
 default:
 log.Println("Acquire:新生成资源")
 return p.factory()
 }
}

//关闭资源池，释放资源
func (p *Pool) Close() {
 p.m.Lock()
 defer p.m.Unlock()

 if p.closed {
 return
 }

 p.closed = true

 //关闭通道，不让写入了
 close(p.res)

 //关闭通道里的资源
 for r:=range p.res {
 r.Close()
 }
}

func (p *Pool) Release(r io.Closer){
 //保证该操作和Close方法的操作是安全的
 p.m.Lock()
 defer p.m.Unlock()

 //资源池都关闭了，就省这一个没有释放的资源了，释放即可
 if p.closed {
 r.Close()
 return
 }

 select {
 case p.res <- r:
 log.Println("资源释放到池子里了")
 default:
 log.Println("资源池满了，释放这个资源吧")
 r.Close()
 }
}

db, err := sql.Open("mysql", "xxxx")

type DB struct {
 waitDuration int64 // Total time waited for new connections.
 mu   sync.Mutex // protects following fields
 freeConn  []*driverConn
 connRequests map[uint64]chan connRequest
 nextRequest uint64 // Next key to use in connRequests.
 numOpen  int // number of opened and pending open connections
 // Used to signal the need for new connections
 // a goroutine running connectionOpener() reads on this chan and
 // maybeOpenNewConnections sends on the chan (one send per needed connection)
 // It is closed during db.Close(). The close tells the connectionOpener
 // goroutine to exit.
 openerCh   chan struct{}
 closed   bool
 maxIdle   int     // zero means defaultMaxIdleConns; negative means 0
 maxOpen   int     // <= 0 means unlimited
 maxLifetime  time.Duration   // maximum amount of time a connection may be reused
 cleanerCh   chan struct{}
 waitCount   int64 // Total number of connections waited for.
 maxIdleClosed  int64 // Total number of connections closed due to idle.
 maxLifetimeClosed int64 // Total number of connections closed due to max free limit.
}

// conn returns a newly-opened or cached *driverConn.
func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn, error) {
 // 先判断db是否已经关闭。
 db.mu.Lock()
 if db.closed {
 db.mu.Unlock()
 return nil, errDBClosed
 }
 // 注意检测context是否已经被超时等原因被取消。
 select {
 default:
 case <-ctx.Done():
 db.mu.Unlock()
 return nil, ctx.Err()
 }
 lifetime := db.maxLifetime

 // 这边如果在freeConn这个切片有空闲连接的话，就left pop一个出列。注意的是，这边因为是切片操作，所以需要前面需要加锁且获取后进行解锁操作。同时判断返回的连接是否已经过期。
 numFree := len(db.freeConn)
 if strategy == cachedOrNewConn && numFree > 0 {
 conn := db.freeConn[0]
 copy(db.freeConn, db.freeConn[1:])
 db.freeConn = db.freeConn[:numFree-1]
 conn.inUse = true
 db.mu.Unlock()
 if conn.expired(lifetime) {
 conn.Close()
 return nil, driver.ErrBadConn
 }
 // Lock around reading lastErr to ensure the session resetter finished.
 conn.Lock()
 err := conn.lastErr
 conn.Unlock()
 if err == driver.ErrBadConn {
 conn.Close()
 return nil, driver.ErrBadConn
 }
 return conn, nil
 }

 // 这边就是等候获取连接的重点了。当空闲的连接为空的时候，这边将会新建一个request（的等待连接 的请求）并且开始等待
 if db.maxOpen > 0 && db.numOpen >= db.maxOpen {
 // 下面的动作相当于往connRequests这个map插入自己的号码牌。
 // 插入号码牌之后这边就不需要阻塞等待继续往下走逻辑。
 req := make(chan connRequest, 1)
 reqKey := db.nextRequestKeyLocked()
 db.connRequests[reqKey] = req
 db.waitCount++
 db.mu.Unlock()

 waitStart := time.Now()

 // Timeout the connection request with the context.
 select {
 case <-ctx.Done():
 // context取消操作的时候，记得从connRequests这个map取走自己的号码牌。
 db.mu.Lock()
 delete(db.connRequests, reqKey)
 db.mu.Unlock()

 atomic.AddInt64(&db.waitDuration, int64(time.Since(waitStart)))

 select {
 default:
 case ret, ok := <-req:
    // 这边值得注意了，因为现在已经被context取消了。但是刚刚放了自己的号码牌进去排队里面。意思是说不定已经发了连接了，所以得注意归还！
 if ok && ret.conn != nil {
  db.putConn(ret.conn, ret.err, false)
 }
 }
 return nil, ctx.Err()
 case ret, ok := <-req:
   // 下面是已经获得连接后的操作了。检测一下获得连接的状况。因为有可能已经过期了等等。
 atomic.AddInt64(&db.waitDuration, int64(time.Since(waitStart)))

 if !ok {
 return nil, errDBClosed
 }
 if ret.err == nil && ret.conn.expired(lifetime) {
 ret.conn.Close()
 return nil, driver.ErrBadConn
 }
 if ret.conn == nil {
 return nil, ret.err
 }
 ret.conn.Lock()
 err := ret.conn.lastErr
 ret.conn.Unlock()
 if err == driver.ErrBadConn {
 ret.conn.Close()
 return nil, driver.ErrBadConn
 }
 return ret.conn, ret.err
 }
 }
 // 下面就是如果上面说的限制情况不存在，可以创建先连接时候，要做的创建连接操作了。
 db.numOpen++ // optimistically
 db.mu.Unlock()
 ci, err := db.connector.Connect(ctx)
 if err != nil {
 db.mu.Lock()
 db.numOpen-- // correct for earlier optimism
 db.maybeOpenNewConnections()
 db.mu.Unlock()
 return nil, err
 }
 db.mu.Lock()
 dc := &driverConn{
 db:  db,
 createdAt: nowFunc(),
 ci:  ci,
 inUse:  true,
 }
 db.addDepLocked(dc, dc)
 db.mu.Unlock()
 return dc, nil
}

...
 // 如果已经超过最大打开数量了，就不需要在回归pool了
 if db.maxOpen > 0 && db.numOpen > db.maxOpen {
 return false
 }
 // 这边是重点了，基本来说就是从connRequest这个map里面随机抽一个在排队等着的请求。取出来后发给他。就不用归还池子了。
 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) // 删除这个在排队的请求。
 if err == nil {
 dc.inUse = true
 }
  // 把连接给这个正在排队的连接。
 req <- connRequest{
 conn: dc,
 err: err,
 }
 return true
 } else if err == nil && !db.closed {
  // 既然没人排队，就看看到了最大连接数目没有。没到就归还给freeConn。
 if db.maxIdleConnsLocked() > len(db.freeConn) {
 db.freeConn = append(db.freeConn, dc)
 db.startCleanerLocked()
 return true
 }
 db.maxIdleClosed++
 }
...

type ConnPool struct {
 ...
 queue chan struct{}

 connsMu  sync.Mutex
 conns  []*Conn
 idleConns []*Conn
 poolSize  int
 idleConnsLen int

 stats Stats

 _closed uint32 // atomic
 closedCh chan struct{}
}

func NewConnPool(opt *Options) *ConnPool {
 ....
 p.checkMinIdleConns()

 if opt.IdleTimeout > 0 && opt.IdleCheckFrequency > 0 {
 go p.reaper(opt.IdleCheckFrequency)
 }
 ....
}

func (p *ConnPool) Get(ctx context.Context) (*Conn, error) {
 if p.closed() {
 return nil, ErrClosed
 }
 
 //这边和前面sql获取连接函数的流程先不同。sql是先看看连接池有没有空闲连接，有的话先获取不到再排队。这边是直接先排队获取令牌，排队函数后面会分析。
 err := p.waitTurn(ctx)
 if err != nil {
 return nil, err
 }
 //前面没出error的话，就已经排队轮候到了。接下来就是获取的流程。
 for {
 p.connsMu.Lock()
  //从空闲连接里面先获取一个空闲连接。
 cn := p.popIdle()
 p.connsMu.Unlock()

 if cn == nil {
   // 没有空闲连接时候直接跳出循环。
 break
 }
 // 判断是否已经过时，是的话close掉了然后继续取出。
 if p.isStaleConn(cn) {
 _ = p.CloseConn(cn)
 continue
 }

 atomic.AddUint32(&p.stats.Hits, 1)
 return cn, nil
 }

 atomic.AddUint32(&p.stats.Misses, 1)
 
 // 如果没有空闲连接的话，这边就直接新建连接了。
 newcn, err := p.newConn(ctx, true)
 if err != nil {
  // 归还令牌。
 p.freeTurn()
 return nil, err
 }

 return newcn, nil
}

func (p *ConnPool) freeTurn() {
 <-p.queue
}
func (p *ConnPool) waitTurn(ctx context.Context) error {
...
 case p.queue <- struct{}{}:
 return nil
...
}

func (p *ConnPool) newConn(ctx context.Context, pooled bool) (*Conn, error) {
 cn, err := p.dialConn(ctx, pooled)
 if err != nil {
 return nil, err
 }

 p.connsMu.Lock()
 p.conns = append(p.conns, cn)
 if pooled {
 // 如果连接池满了，会在后面移除。
 if p.poolSize >= p.opt.PoolSize {
 cn.pooled = false
 } else {
 p.poolSize++
 }
 }
 p.connsMu.Unlock()
 return cn, nil
}

func (p *ConnPool) Put(cn *Conn) {
 if cn.rd.Buffered() > 0 {
 internal.Logger.Printf("Conn has unread data")
 p.Remove(cn, BadConnError{})
 return
 }
 //这就是我们刚刚说的后面了，前面标记过不要入池的，这边就删除了。当然了，里面也会进行freeTurn操作。
 if !cn.pooled {
  // 这个方法就是前面的标志位，判断里面可以知道，前面标志不要池化的，这里会将它删除。
 p.Remove(cn, nil)
 return
 }

 p.connsMu.Lock()
 p.idleConns = append(p.idleConns, cn)
 p.idleConnsLen++
 p.connsMu.Unlock()
 //我们可以看到很明显的这个归还号码牌的动作。
 p.freeTurn()
}