Go建立Grpc連結池實現過程詳解

2023-03-05 14:01:06

常規用法

gRPC 四種基本使用

請求響應模式
使用者端資料流模式
伺服器端資料流模式
雙向流模式

常見的gRPC呼叫寫法

func main(){
	//... some code
	// 連結grpc服務
	conn , err := grpc.Dial(":8000",grpc.WithInsecure)
	if err != nil {
		//...log
	}
	defer conn.Close()
	//...some code

存在的問題：面臨高並行的情況，效能問題很容易就會出現，例如我們在做效能測試的時候，就會發現，打一會效能測試，使用者端請求伺服器端的時候就會報錯：

rpc error: code = Unavailable desc = all SubConns are in TransientFailure, latest connection error: connection error: desc = "transport: Error while dialing dial tcp xxx:xxx: connect: connection refused

實際去檢視問題的時候，很明顯，這是 gRPC 的連線數被打滿了，很多連線都還未完全釋放。[#本文來源：janrs.com#]

gRPC 的通訊本質上也是 TCP 的連線，那麼一次連線就需要三次握手，和四次揮手，每一次建立連線和釋放連線的時候，都需要走這麼一個過程，如果我們頻繁的建立和釋放連線，這對於資源和效能其實都是一個大大的浪費。

在伺服器端，gRPC 伺服器端的連結管理不用我們操心，但是 gRPC 使用者端的連結管理非常有必要關心，要實現複用使用者端的連線。

建立連結池

建立連結池需要考慮的問題：

連線池是否支援擴縮容
空閒的連線是否支援超時自行關閉，是否支援保活
池子滿的時候，處理的策略是什麼樣的

建立連結池介面

type Pool interface {
	// 獲取一個新的連線 ， 當關閉連線的時候，會將該連線放入到池子中
   Get() (Conn, error)
	// 關閉連線池，自然連線池子中的連線也不再可用
   Close() error
	//[#本文來源：janrs.com#]
   Status() string
}

實現連結池介面

建立連結池程式碼

func New(address string, option Options) (Pool, error) {
   if address == "" {
      return nil, errors.New("invalid address settings")
   }
   if option.Dial == nil {
      return nil, errors.New("invalid dial settings")
   }
   if option.MaxIdle &lt;= 0 || option.MaxActive &lt;= 0 || option.MaxIdle &gt; option.MaxActive {
      return nil, errors.New("invalid maximum settings")
   }
   if option.MaxConcurrentStreams &lt;= 0 {
      return nil, errors.New("invalid maximun settings")
   }
   p := &amp;pool{
      index:   0,
      current: int32(option.MaxIdle),
      ref:     0,
      opt:     option,
      conns:   make([]*conn, option.MaxActive),
      address: address,
      closed:  0,
   }
   for i := 0; i &lt; p.opt.MaxIdle; i++ {
      c, err := p.opt.Dial(address)
      if err != nil {
         p.Close()
         return nil, fmt.Errorf("dial is not able to fill the pool: %s", err)
      }
      p.conns[i] = p.wrapConn(c, false)
   }
   log.Printf("new pool success: %vn", p.Status())
   return p, nil
}

關於以上的程式碼，需要特別注意每一個連線的建立也是在 New 裡面完成的，[#本文來源：janrs.com#]只要有 1 個連線未建立成功，那麼咱們的連線池就算是建立失敗，咱們會呼叫 p.Close() 將之前建立好的連線全部釋放掉。

關閉連結池程式碼

// 關閉連線池
func (p *pool) Close() error {
   atomic.StoreInt32(&p.closed, 1)
   atomic.StoreUint32(&p.index, 0)
   atomic.StoreInt32(&p.current, 0)
   atomic.StoreInt32(&p.ref, 0)
   p.deleteFrom(0)
   log.Printf("[janrs.com]close pool success: %vn", p.Status())
   return nil
}

從具體位置刪除連結池程式碼

// 清除從 指定位置開始到 MaxActive 之間的連線
func (p *pool) deleteFrom(begin int) {
   for i := begin; i < p.opt.MaxActive; i++ {
      p.reset(i)
   }
}

銷燬具體的連結程式碼

// 清除具體的連線
func (p *pool) reset(index int) {
   conn := p.conns[index]
   if conn == nil {
      return
   }
   conn.reset()
   p.conns[index] = nil
}

關閉連結

程式碼

func (c *conn) reset() error {
   cc := c.cc
   c.cc = nil
   c.once = false
   // 本文部落格來源：janrs.com
   if cc != nil {
      return cc.Close()
   }
   return nil
}
func (c *conn) Close() error {
   c.pool.decrRef()
   if c.once {
      return c.reset()
   }
   return nil
}

在使用連線池通過 pool.Get() 拿到具體的連線控制程式碼 conn 之後，會使用 conn.Close()關閉連線，實際上也是會走到上述的 Close() 實現的位置，但是並未指定當然也沒有許可權顯示的指定將 once 置位為 false ，也就是對於呼叫者來說，是關閉了連線，對於連線池來說，實際上是將連線歸還到連線池中。

擴縮容

關鍵程式碼

func (p *pool) Get() (Conn, error) {
   // the first selected from the created connections
   nextRef := p.incrRef()
   p.RLock()
   current := atomic.LoadInt32(&p.current)
   p.RUnlock()
   if current == 0 {
      return nil, ErrClosed
   }
   if nextRef <= current*int32(p.opt.MaxConcurrentStreams) {
      next := atomic.AddUint32(&p.index, 1) % uint32(current)
      return p.conns[next], nil
   }
   // 本文部落格來源：janrs.com
   // the number connection of pool is reach to max active
   if current == int32(p.opt.MaxActive) {
      // the second if reuse is true, select from pool's connections
      if p.opt.Reuse {
         next := atomic.AddUint32(&p.index, 1) % uint32(current)
         return p.conns[next], nil
      }
      // the third create one-time connection
      c, err := p.opt.Dial(p.address)
      return p.wrapConn(c, true), err
   }
   // the fourth create new connections given back to pool
   p.Lock()
   current = atomic.LoadInt32(&p.current)
   if current < int32(p.opt.MaxActive) && nextRef > current*int32(p.opt.MaxConcurrentStreams) {
      // 2 times the incremental or the remain incremental  ##janrs.com
      increment := current
      if current+increment > int32(p.opt.MaxActive) {
         increment = int32(p.opt.MaxActive) - current
      }
      var i int32
      var err error
      for i = 0; i < increment; i++ {
         c, er := p.opt.Dial(p.address)
         if er != nil {
            err = er
            break
         }
         p.reset(int(current + i))
         p.conns[current+i] = p.wrapConn(c, false)
      }
	  // 本文部落格來源：janrs.com
      current += i
      log.Printf("#janrs.com#grow pool: %d ---> %d, increment: %d, maxActive: %dn",
         p.current, current, increment, p.opt.MaxActive)
      atomic.StoreInt32(&p.current, current)
      if err != nil {
         p.Unlock()
         return nil, err
      }
   }
   p.Unlock()
   next := atomic.AddUint32(&p.index, 1) % uint32(current)
   return p.conns[next], nil
}

Get 程式碼邏輯

先增加連線的參照計數，如果在設定 current*int32(p.opt.MaxConcurrentStreams) 範圍內，那麼直接取連線進行使用即可。
若當前的連線數達到了最大活躍的連線數，那麼就看我們新建池子的時候傳遞的 option 中的 reuse 引數是否是 true，若是複用，則隨機取出連線池中的任意連線提供使用，如果不復用，則新建一個連線。
其餘的情況，就需要我們進行 2 倍或者 1 倍的數量對連線池進行擴容了。

也可以在 Get 的實現上進行縮容，具體的縮容策略可以根據實際情況來定，例如當參照計數 nextRef 只有當前活躍連線數的 10% 的時候（這只是一個例子），就可以考慮縮容了。