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
  //連接多少時間沒有使用則被關閉
  IdleConnTimeout time.Duration
  
  //禁用長連接，使用短連接
  DisableKeepAlives bool
}

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

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

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

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

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?

func (t *Transport) queueForIdleConn(w *wantConn) (delivered bool) {
  //如果配置了空閑超時時間，獲取到連接需要檢測，超時則關閉連接
  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)
      //超時了，關閉連接
      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
}

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

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
  }

}

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

queue  []*wantConn

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

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

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
}