连接池设计导致的 Redis Proxy 负载不均衡

// GetContext gets a connection using the provided context.
//
// The provided Context must be non-nil. If the context expires before the
// connection is complete, an error is returned. Any expiration on the context
// will not affect the returned connection.
//
// If the function completes without error, then the application must close the
// returned connection.
func (p *Pool) GetContext(ctx context.Context) (Conn, error) {
	// Wait until there is a vacant connection in the pool.
  // 判断是否等待空闲连接
  ...


	// Prune stale connections at the back of the idle list.
  // 从尾部开始清理过期的连接
  ...

	// Get idle connection from the front of idle list.
	for p.idle.front != nil {

    // 获取 idle 头 的 conn
		pc := p.idle.front
    // 将头移除
		p.idle.popFront()
		p.mu.Unlock()
    // 有效性检测
		if (p.TestOnBorrow == nil || p.TestOnBorrow(pc.c, pc.t) == nil) &&
			(p.MaxConnLifetime == 0 || nowFunc().Sub(pc.created) < p.MaxConnLifetime) {
      // 将 Pool 和 conn 包装到 activeConn
			return &activeConn{p: p, pc: pc}, nil
		}
		pc.c.Close()
		p.mu.Lock()
		p.active--
	}

	// Check for pool closed before dialing a new connection.
  // 判断 pool 是否已关闭
  ...

	// Handle limit for p.Wait == false.
  // 判断是否达到最大活跃连接数限制
  ...

  // 创建新连接
  ...
}

// Pool 核心字段
type Pool struct {
	...

	mu           sync.Mutex    // mu protects the following fields
	closed       bool          // set to true when the pool is closed.
	active       int           // the number of open connections in the pool
	initOnce     sync.Once     // the init ch once func
	ch           chan struct{} // limits open connections when p.Wait is true
	idle         idleList      // idle connections
	waitCount    int64         // total number of connections waited for.
	waitDuration time.Duration // total time waited for new connections.
}

func (ac *activeConn) Close() (err error) {
	// 一大堆状态相关的状态取消操作
  // 
	return ac.firstError(
		err,
		err2,
		ac.p.put(pc, ac.state != 0 || pc.c.Err() != nil),
	)
}


func (p *Pool) put(pc *poolConn, forceClose bool) error {
	p.mu.Lock()
	if !p.closed && !forceClose {
		pc.t = nowFunc()

    // push 到 idle 头部
		p.idle.pushFront(pc)
		if p.idle.count > p.MaxIdle {
			pc = p.idle.back
			p.idle.popBack()
		} else {
			pc = nil
		}
	}

	if pc != nil {
		p.mu.Unlock()
		pc.c.Close()
		p.mu.Lock()
		p.active--
	}

	if p.ch != nil && !p.closed {
		p.ch <- struct{}{}
	}
	p.mu.Unlock()
	return nil
}