var (   doOption = &httpreq.HttpDoOption{      DisableLog: true,   }    triggerHandlerClient = &http.Client{      Timeout: 30 * time.Minute, // 30分钟兜底 实际超时由handle时设置      Transport: &http.Transport{         Proxy:               http.ProxyFromEnvironment,         DialContext:         knet.WrapTcpDialer(time.Second*5, time.Minute, nil),         ForceAttemptHTTP2:   true,         MaxIdleConns:        256,         MaxIdleConnsPerHost: 256,         MaxConnsPerHost:     512,         IdleConnTimeout:     time.Minute,         TLSHandshakeTimeout: 10 * time.Second,      },   })

knet.WrapTcpDialer(time.Second*5, time.Minute, nil) ；

package main import (   "fmt"   "io/ioutil"   "net/http"   "net/http/httptrace"   "sync"   "testing") func TestAAA(t *testing.T) {   c := make(chan struct{}, 5)   wg := sync.WaitGroup{}   for i := 0; i < 20; i++ {      c <- struct{}{}      go func() {         wg.Add(1)         defer wg.Done()         HttpGet()         <-c      }()   }   wg.Wait()   fmt.Println("getConnCount", getConnCount)   fmt.Println("getDNSCount", getDNSCount)} var getConnCount = 0var getConnCountLock = sync.Mutex{} var getDNSCount = 0var getDNSCountLock = sync.Mutex{} var httpTrace = &httptrace.ClientTrace{   ConnectDone: func(network, addr string, err error) {      getConnCountLock.Lock()      defer getConnCountLock.Unlock()      getConnCount++   },   DNSDone: func(info httptrace.DNSDoneInfo) {      getDNSCountLock.Lock()      defer getDNSCountLock.Unlock()      getDNSCount++   },} func HttpGet() {   req, _ := http.NewRequest("GET", "https://www.baidu.com", nil)   req = req.WithContext(httptrace.WithClientTrace(req.Context(), httpTrace))   resp, err := http.DefaultTransport.RoundTrip(req)   if err != nil {      fmt.Println(err)      return   }   defer resp.Body.Close()} func HttpGet2() {   req, _ := http.NewRequest("GET", "https://www.baidu.com", nil)   req = req.WithContext(httptrace.WithClientTrace(req.Context(), httpTrace))   resp, err := http.DefaultTransport.RoundTrip(req)   if err != nil {      fmt.Println(err)      return   }   defer resp.Body.Close()   _, _ = ioutil.ReadAll(resp.Body)}

_, _ = ioutil.ReadAll(resp.Body)

func (pc *persistConn) readLoop() {   alive := true   for alive {           waitForBodyRead := make(chan bool, 2)      body := &bodyEOFSignal{         body: resp.Body,        // 非读取完关闭，输入false         earlyCloseFn: func() error {            waitForBodyRead <- false            <-eofc // will be closed by deferred call at the end of the function            return nil          },        // 正常读取完后关闭，输入 isEOF = true         fn: func(err error) error {            isEOF := err == io.EOF            waitForBodyRead <- isEOF            if isEOF {               <-eofc // see comment above eofc declaration            } else if err != nil {               if cerr := pc.canceled(); cerr != nil {                  return cerr               }            }            return err         },      }         // 赋值resp的body，加强了 close 和 eof 处理的，后续调用resp.Body.Close() = bodyEOFSignal.Close()      resp.Body = body      ......       // Before looping back to the top of this function and peeking on      // the bufio.Reader, wait for the caller goroutine to finish      // reading the response body. (or for cancellation or death)      select {      case bodyEOF := <-waitForBodyRead:         replaced := pc.t.replaceReqCanceler(rc.cancelKey, nil) // before pc might return to idle pool         alive = alive &&            // 非读取完，设置alive是false，标识连接不能继续使用            bodyEOF &&            !pc.sawEOF &&            pc.wroteRequest() &&            replaced && tryPutIdleConn(trace)         if bodyEOF {            eofc <- struct{}{}         }      case <-rc.req.Cancel:         alive = false         pc.t.CancelRequest(rc.req)      case <-rc.req.Context().Done():         alive = false         pc.t.cancelRequest(rc.cancelKey, rc.req.Context().Err())      case <-pc.closech:         alive = false      }    }} type bodyEOFSignal struct {   body         io.ReadCloser   mu           sync.Mutex        // guards following 4 fields   closed       bool              // whether Close has been called   rerr         error             // sticky Read error   fn           func(error) error // err will be nil on Read io.EOF   earlyCloseFn func() error      // optional alt Close func used if io.EOF not seen} func (es *bodyEOFSignal) Close() error {   es.mu.Lock()   defer es.mu.Unlock()   if es.closed {      return nil   }   es.closed = true    // 如果非io.EOF，也就是读取完数据的情况，调用earlyCloseFn方法   if es.earlyCloseFn != nil && es.rerr != io.EOF {      return es.earlyCloseFn()   }   err := es.body.Close()   return es.condfn(err)} // caller must hold es.mu.func (es *bodyEOFSignal) condfn(err error) error {   if es.fn == nil {      return err   }   err = es.fn(err)   es.fn = nil   return err}