Make free-connection stack a LIFO.

internal/pool/pool.go

@@ -50,7 +50,7 @@ type ConnPool struct {
 	idleTimeout time.Duration
 
 	conns     *connList
-	freeConns chan *Conn
+	freeConns *connStack
 	stats     PoolStats
 
 	_closed int32
@@ -67,7 +67,7 @@ func NewConnPool(dial dialer, poolSize int, poolTimeout, idleTimeout time.Durati
 		idleTimeout: idleTimeout,
 
 		conns:     newConnList(poolSize),
-		freeConns: make(chan *Conn, poolSize),
+		freeConns: newConnStack(poolSize),
 	}
 	if idleTimeout > 0 {
 		go p.reaper()
@@ -87,44 +87,33 @@ func (p *ConnPool) isIdle(cn *Conn) bool {
 // there are no connections.
 func (p *ConnPool) First() *Conn {
 	for {
-		select {
-		case cn := <-p.freeConns:
-			if p.isIdle(cn) {
-				var err error
-				cn, err = p.replace(cn)
-				if err != nil {
-					Logger.Printf("pool.replace failed: %s", err)
-					continue
-				}
+		cn := p.freeConns.Pop()
+		if cn != nil && cn.IsStale(p.idleTimeout) {
+			var err error
+			cn, err = p.replace(cn)
+			if err != nil {
+				Logger.Printf("pool.replace failed: %s", err)
+				continue
 			}
-			return cn
-		default:
-			return nil
 		}
+		return cn
 	}
-	panic("not reached")
 }
 
 // wait waits for free non-idle connection. It returns nil on timeout.
 func (p *ConnPool) wait() *Conn {
-	deadline := time.After(p.poolTimeout)
 	for {
-		select {
-		case cn := <-p.freeConns:
-			if p.isIdle(cn) {
-				var err error
-				cn, err = p.replace(cn)
-				if err != nil {
-					Logger.Printf("pool.replace failed: %s", err)
-					continue
-				}
+		cn := p.freeConns.PopWithTimeout(p.poolTimeout)
+		if cn != nil && cn.IsStale(p.idleTimeout) {
+			var err error
+			cn, err = p.replace(cn)
+			if err != nil {
+				Logger.Printf("pool.replace failed: %s", err)
+				continue
 			}
-			return cn
-		case <-deadline:
-			return nil
 		}
+		return cn
 	}
-	panic("not reached")
 }
 
 func (p *ConnPool) dial() (net.Conn, error) {
@@ -198,7 +187,7 @@ func (p *ConnPool) Put(cn *Conn) error {
 		Logger.Print(err)
 		return p.Replace(cn, err)
 	}
-	p.freeConns <- cn
+	p.freeConns.Push(cn)
 	return nil
 }
 
@@ -223,7 +212,7 @@ func (p *ConnPool) Replace(cn *Conn, reason error) error {
 	if err != nil {
 		return err
 	}
-	p.freeConns <- newcn
+	p.freeConns.Push(newcn)
 	return nil
 }
 
@@ -234,7 +223,7 @@ func (p *ConnPool) Len() int {
 
 // FreeLen returns number of free connections.
 func (p *ConnPool) FreeLen() int {
-	return len(p.freeConns)
+	return p.freeConns.Len()
 }
 
 func (p *ConnPool) Stats() *PoolStats {
@@ -273,11 +262,12 @@ func (p *ConnPool) reaper() {
 			break
 		}
 
-		// pool.First removes idle connections from the pool and
-		// returns first non-idle connection. So just put returned
-		// connection back.
-		if cn := p.First(); cn != nil {
-			p.Put(cn)
+		for {
+			cn := p.freeConns.ShiftStale(p.idleTimeout)
+			if cn == nil {
+				break
+			}
+			_ = p.conns.Remove(cn)
 		}
 	}
 }