溫馨提示×

溫馨提示×

您好，登錄后才能下訂單哦！

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務(wù)條款》

Golang如何實現(xiàn)連接池的方法

發(fā)布時間：2020-08-20 09:33:53 來源：億速云 閱讀：643 作者：小新 欄目：開發(fā)技術(shù)

Golang如何實現(xiàn)連接池的方法？這個問題可能是我們?nèi)粘W習或工作經(jīng)常見到的。希望通過這個問題能讓你收獲頗深。下面是小編給大家?guī)淼膮⒖純?nèi)容，讓我們一起來看看吧！

問題引入

作為一名Golang開發(fā)者，線上環(huán)境遇到過好幾次連接數(shù)暴增問題（mysql/redis/kafka等）。

糾其原因，Golang作為常駐進程，請求第三方服務(wù)或者資源完畢后，需要手動關(guān)閉連接，否則連接會一直存在。而很多時候，開發(fā)者不一定記得關(guān)閉這個連接。

這樣是不是很麻煩？于是有了連接池。顧名思義，連接池就是管理連接的；我們從連接池獲取連接，請求完畢后再將連接還給連接池；連接池幫我們做了連接的建立、復用以及回收工作。

在設(shè)計與實現(xiàn)連接池時，我們通常需要考慮以下幾個問題：

  • 連接池的連接數(shù)目是否有限制，最大可以建立多少個連接？
  • 當連接長時間沒有使用，需要回收該連接嗎？
  • 業(yè)務(wù)請求需要獲取連接時，此時若連接池無空閑連接且無法新建連接，業(yè)務(wù)需要排隊等待嗎？
  • 排隊的話又存在另外的問題，隊列長度有無限制，排隊時間呢？

Golang連接池實現(xiàn)原理

我們以Golang HTTP連接池為例，分析連接池的實現(xiàn)原理。

結(jié)構(gòu)體Transport

Transport結(jié)構(gòu)定義如下：

type Transport struct {
  //操作空閑連接需要獲取鎖
  idleMu    sync.Mutex
  //空閑連接池，key為協(xié)議目標地址等組合
  idleConn   map[connectMethodKey][]*persistConn // most recently used at end
  //等待空閑連接的隊列，基于切片實現(xiàn)，隊列大小無限制
  idleConnWait map[connectMethodKey]wantConnQueue // waiting getConns
  
  //排隊等待建立連接需要獲取鎖
  connsPerHostMu  sync.Mutex
  //每個host建立的連接數(shù)
  connsPerHost   map[connectMethodKey]int
  //等待建立連接的隊列，同樣基于切片實現(xiàn)，隊列大小無限制
  connsPerHostWait map[connectMethodKey]wantConnQueue // waiting getConns
  
  //最大空閑連接數(shù)
  MaxIdleConns int
  //每個目標host最大空閑連接數(shù)；默認為2（注意默認值）
  MaxIdleConnsPerHost int
  //每個host可建立的最大連接數(shù)
  MaxConnsPerHost int
  //連接多少時間沒有使用則被關(guān)閉
  IdleConnTimeout time.Duration
  
  //禁用長連接，使用短連接
  DisableKeepAlives bool
}

可以看到，連接護著隊列，都是一個map結(jié)構(gòu)，而key為協(xié)議目標地址等組合，即同一種協(xié)議與同一個目標host可建立的連接或者空閑連接是有限制的。

需要特別注意的是，MaxIdleConnsPerHost默認等于2，即與目標主機最多只維護兩個空閑連接。這會導致什么呢？

如果遇到突發(fā)流量，瞬間建立大量連接，但是回收連接時，由于最大空閑連接數(shù)的限制，該聯(lián)機不能進入空閑連接池，只能直接關(guān)閉。結(jié)果是，一直新建大量連接，又關(guān)閉大量連，業(yè)務(wù)機器的TIME_WAIT連接數(shù)隨之突增。

線上有些業(yè)務(wù)架構(gòu)是這樣的：客戶端 ===> LVS ===> Nginx ===> 服務(wù)。LVS負載均衡方案采用DR模式，LVS與Nginx配置統(tǒng)一VIP。此時在客戶端看來，只有一個IP地址，只有一個Host。上述問題更為明顯。

最后，Transport也提供了配置DisableKeepAlives，禁用長連接，使用短連接訪問第三方資源或者服務(wù)。

連接獲取與回收

Transport結(jié)構(gòu)提供下面兩個方法實現(xiàn)連接的獲取與回收操作。

func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error) {}

func (t *Transport) tryPutIdleConn(pconn *persistConn) error {}

連接的獲取主要分為兩步走：1）嘗試獲取空閑連接；2）嘗試新建連接：

//getConn方法內(nèi)部實現(xiàn)

if delivered := t.queueForIdleConn(w); delivered {
  return pc, nil
}
  
t.queueForDial(w)

當然，可能獲取不到連接而需要排隊，此時怎么辦呢？當前會阻塞當前協(xié)程了，直到獲取連接為止，或者httpclient超時取消請求：

select {
  case <-w.ready:
    return w.pc, w.err
    
  //超時被取消
  case <-req.Cancel:
    return nil, errRequestCanceledConn
  ……
}

var errRequestCanceledConn = errors.New("net/http: request canceled while waiting for connection") // TODO: unify&#63;

排隊等待空閑連接的邏輯如下：

func (t *Transport) queueForIdleConn(w *wantConn) (delivered bool) {
  //如果配置了空閑超時時間，獲取到連接需要檢測，超時則關(guān)閉連接
  if t.IdleConnTimeout > 0 {
    oldTime = time.Now().Add(-t.IdleConnTimeout)
  }
  
  if list, ok := t.idleConn[w.key]; ok {
    for len(list) > 0 && !stop {
      pconn := list[len(list)-1]
      tooOld := !oldTime.IsZero() && pconn.idleAt.Round(0).Before(oldTime)
      //超時了，關(guān)閉連接
      if tooOld {
        go pconn.closeConnIfStillIdle()
      }
      
      //分發(fā)連接到wantConn
      delivered = w.tryDeliver(pconn, nil)
    }
  }
  
  //排隊等待空閑連接
  q := t.idleConnWait[w.key]
  q.pushBack(w)
  t.idleConnWait[w.key] = q
}

排隊等待新建連接的邏輯如下：

func (t *Transport) queueForDial(w *wantConn) {
  //如果沒有限制最大連接數(shù)，直接建立連接
  if t.MaxConnsPerHost <= 0 {
    go t.dialConnFor(w)
    return
  }
  
  //如果沒超過連接數(shù)限制，直接建立連接
  if n := t.connsPerHost[w.key]; n < t.MaxConnsPerHost {
    go t.dialConnFor(w)
    return
  }
  
  //排隊等待連接建立
  q := t.connsPerHostWait[w.key]
  q.pushBack(w)
  t.connsPerHostWait[w.key] = q
}

連接建立完成后，同樣會調(diào)用tryDeliver分發(fā)連接到wantConn，同時關(guān)閉通道w.ready，這樣主協(xié)程糾接觸阻塞了。

func (w *wantConn) tryDeliver(pc *persistConn, err error) bool {
  w.pc = pc
  close(w.ready)
}

請求處理完成后，通過tryPutIdleConn將連接放回連接池；這時候如果存在等待空閑連接的協(xié)程，則需要分發(fā)復用該連接。另外，在回收連接時，還需要校驗空閑連接數(shù)目是否超過限制：

func (t *Transport) tryPutIdleConn(pconn *persistConn) error {
  //禁用長連接；或者最大空閑連接數(shù)不合法
  if t.DisableKeepAlives || t.MaxIdleConnsPerHost < 0 {
    return errKeepAlivesDisabled
  }
  
  if q, ok := t.idleConnWait[key]; ok {
    //如果等待隊列不為空，分發(fā)連接
    for q.len() > 0 {
      w := q.popFront()
      if w.tryDeliver(pconn, nil) {
        done = true
        break
      }
    }
  }
  
  //空閑連接數(shù)目超過限制，默認為DefaultMaxIdleConnsPerHost=2
  idles := t.idleConn[key]
  if len(idles) >= t.maxIdleConnsPerHost() {
    return errTooManyIdleHost
  }

}

空閑連接超時關(guān)閉

Golang HTTP連接池如何實現(xiàn)空閑連接的超時關(guān)閉邏輯呢？從上述queueForIdleConn邏輯可以看到，每次在獲取到空閑連接時，都會檢測是否已經(jīng)超時，超時則關(guān)閉連接。

那如果沒有業(yè)務(wù)請求到達，一直不需要獲取連接，空閑連接就不會超時關(guān)閉嗎？其實在將空閑連接添加到連接池時，Golang同時還設(shè)置了定時器，定時器到期后，自然會關(guān)閉該連接。

pconn.idleTimer = time.AfterFunc(t.IdleConnTimeout, pconn.closeConnIfStillIdle)

排隊隊列怎么實現(xiàn)

怎么實現(xiàn)隊列模型呢？很簡單，可以基于切片：

queue  []*wantConn

//入隊
queue = append(queue, w)

//出隊
v := queue[0]
queue[0] = nil
queue = queue[1:]

這樣有什么問題嗎？隨著頻繁的入隊與出隊操作，切片queue的底層數(shù)組，會有大量空間無法復用而造成浪費。除非該切片執(zhí)行了擴容操作。

Golang在實現(xiàn)隊列時，使用了兩個切片head和tail；head切片用于出隊操作，tail切片用于入隊操作；出隊時，如果head切片為空，則交換head與tail。通過這種方式，Golang實現(xiàn)了底層數(shù)組空間的復用。

func (q *wantConnQueue) pushBack(w *wantConn) {
  q.tail = append(q.tail, w)
}

func (q *wantConnQueue) popFront() *wantConn {
  if q.headPos >= len(q.head) {
    if len(q.tail) == 0 {
      return nil
    }
    // Pick up tail as new head, clear tail.
    q.head, q.headPos, q.tail = q.tail, 0, q.head[:0]
  }
  w := q.head[q.headPos]
  q.head[q.headPos] = nil
  q.headPos++
  return w
}

感謝各位的閱讀！看完上述內(nèi)容，你們對Golang如何實現(xiàn)連接池的方法大概了解了嗎？希望文章內(nèi)容對大家有所幫助。如果想了解更多相關(guān)文章內(nèi)容，歡迎關(guān)注億速云行業(yè)資訊頻道。

向AI問一下細節(jié)

免責聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點不代表本網(wǎng)站立場，如果涉及侵權(quán)請聯(lián)系站長郵箱：is@yisu.com進行舉報，并提供相關(guān)證據(jù)，一經(jīng)查實，將立刻刪除涉嫌侵權(quán)內(nèi)容。

AI
助
手