golang http2客户端处理逻辑分析

结构

客户端transport

transport包含了各种配置选项和功能，用于管理与服务器的 HTTP/2 连接和请求

type Transport struct {
  // 用于创建 TLS 连接的可选拨号函数，支持上下文。如果未设置，将使用 tls.Dial。
  // 如果返回的net.Conn有像tls.Conn的ConnectionState方法，那么将会用于设置http.Response.TLS
	DialTLSContext func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error)

	// Deprecated: Use DialTLSContext instead, which allows the transport
	// to cancel dials as soon as they are no longer needed.
	// If both are set, DialTLSContext takes priority.
	DialTLS func(network, addr string, cfg *tls.Config) (net.Conn, error)

  // TLS客户端配置
	TLSClientConfig *tls.Config

  // 客户端连接池
	ConnPool ClientConnPool

  // 如果为 true，则防止传输请求带有 "Accept-Encoding: gzip" 请求头。当传输自动请求 gzip 并接收到 gzip 响应时，会透明地解码响应体。但如果用户明确请求了 gzip，则不会自动解压。
	DisableCompression bool

  // 是否允许http2请求使用不安全的http
  // Note that this does not enable h2c support.
	AllowHTTP bool

  // 在初始设置帧中发送的 SETTINGS_MAX_HEADER_LIST_SIZE 值，表示允许的响应头的字节数。0 表示使用默认限制（目前为 10MB）。如果要告知对等方无限制，则设置为最高值 0xffffffff。
	MaxHeaderListSize uint32

  // 在初始设置帧中发送的 SETTINGS_MAX_FRAME_SIZE 值，表示发送者愿意接收的最大帧负载大小。如果为 0，则不发送设置，由对等方提供值（应该为 16384）
  	// according to the spec: https://datatracker.ietf.org/doc/html/rfc7540#section-6.5.2.
	// Values are bounded in the range 16k to 16M.
	MaxReadFrameSize uint32

  // 在初始设置帧中发送的 SETTINGS_HEADER_TABLE_SIZE 值，表示用于解码头块的头压缩表的最大大小。如果为 0，则使用默认值 4096。
	MaxDecoderHeaderTableSize uint32

  // 指定用于编码请求头的头压缩表的最大上限。接收到的 SETTINGS_HEADER_TABLE_SIZE 设置将限制在该上限内。如果为 0，则使用默认值 4096。
	MaxEncoderHeaderTableSize uint32

  // 控制是否全局尊重服务端的 SETTINGS_MAX_CONCURRENT_STREAMS。如果为 false，则根据需要创建新的 TCP 连接，每个连接都遵守 SETTINGS_MAX_CONCURRENT_STREAMS 限制。如果为 true，则解释为全局限制，调用 RoundTrip 时会在需要时等待。
	StrictMaxConcurrentStreams bool

  // 空闲（保持活动）连接在关闭之前可以保持空闲的最长时间。0 表示无限制
	IdleConnTimeout time.Duration

  // 在连接上没有接收到帧后进行健康检查（使用 ping 帧）的超时时间。如果为 0，则不进行健康检查。
	ReadIdleTimeout time.Duration

	// 在未收到 Ping 响应后关闭连接的超时时间。默认是 15 秒
	PingTimeout time.Duration

  // 连接关闭的超时时间，超过这个时间就不能写入数据了。
  // 超时从数据可以写入时开始，并在写入任何字节时扩展。
	WriteByteTimeout time.Duration

  // 如果非空，在 HTTP/2 传输错误时调用。用于增量监控指标（如 expvar 或 Prometheus 指标）
	CountError func(errType string)

  // 如果非空，则是使用此传输的标准库传输。其设置将被使用（但不包括 RoundTrip 方法等）
	t1 *http.Transport

  // 用于确保连接池只初始化一次
	connPoolOnce  sync.Once
  // 非空版本的 ConnPool
	connPoolOrDef ClientConnPool

	syncHooks *testSyncHooks
}

客户端连接

客户端连接包含了连接状态、流量控制、请求控制与数据处理等

type ClientConn struct {
  // 连接关联的Transport
	t             *Transport
  // 低层网络连接
	tconn         net.Conn             // usually *tls.Conn, except specialized impls
  // TLS连接状态
	tlsState      *tls.ConnectionState // nil only for specialized impls
  // 代表连接是否正在被复用
	reused        uint32               
  // 代表连接是否正在被单个http请求使用
	singleUse     bool
  
	getConnCalled bool                 // used by clientConnPool

  // readLoop goroutine读取发生错误
	readerDone chan struct{} // closed on error
	readerErr  error         // set before readerDone is closed

  // 空闲超时定时器
	idleTimeout time.Duration // or 0 for never
	idleTimer   timer

	mu              sync.Mutex // guards following
	cond            *sync.Cond // hold mu; broadcast on flow/closed changes
  
  // 连接级别的流量控制额度
	flow            outflow    
  // 对端的连接级别的流量控制额度
	inflow          inflow  
  
  // 标记连接不可被复用
	doNotReuse      bool       
  // 表示连接正在被关闭
	closing         bool
  // 表示连接已经被关闭
	closed          bool
  // 表示是否已经收到setting帧
	seenSettings    bool                     
  // 表示是否期待setting帧的回应
	wantSettingsAck bool                     
  // 收到的GOAWAY帧
	goAway          *GoAwayFrame             
	goAwayDebug     string                   // goAway frame's debug data, retained as a string

  // 客户端发起的stream
	streams         map[uint32]*clientStream 
  // 等待请求预留的流数量
	streamsReserved int                      // incr by ReserveNewRequest; decr on RoundTrip
  // 下一个stream id
	nextStreamID    uint32
  // 等待请求数量
	pendingRequests int                       // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams
  
  // 用于存储正在传输的 ping 数据到通知通道
	pings           map[[8]byte]chan struct{} // in flight ping data to notification channel
	// 用于从连接中读取数据的缓冲读取器
	br              *bufio.Reader
  
  // 最后一次活动的时间和最后一次空闲的时间
	lastActive      time.Time
	lastIdle        time.Time // time last idle
  
  // 这些字段表示从对端接收到的设置，包括最大帧大小、最大并发流数量、对端最大头列表大小、对端最大头表大小和初始窗口大小
	maxFrameSize           uint32
	maxConcurrentStreams   uint32
	peerMaxHeaderListSize  uint64
	peerMaxHeaderTableSize uint32
	initialWindowSize      uint32

  // 用于控制发送新请求的访问。向 reqHeaderMu 写入以锁定它，从中读取以解锁它
	reqHeaderMu chan struct{}

	// wmu is held while writing.
	// Acquire BEFORE mu when holding both, to avoid blocking mu on network writes.
	// Only acquire both at the same time when changing peer settings.
	wmu  sync.Mutex
  // 持有网络连接的缓存写入器
	bw   *bufio.Writer
  // 帧编解码器
	fr   *Framer
	werr error        // first write error that has occurred
  
  // 字节缓冲区和一个 HPACK 编码器，用于编码 HTTP 头部
	hbuf bytes.Buffer // HPACK encoder writes into this
	henc *hpack.Encoder

	syncHooks *testSyncHooks // can be nil
}

客户端流

在 HTTP/2 中，一个 TCP 连接可以被划分为多个流，每个流都有一个唯一的标识符。这些流可以并行地传输请求和响应消息，而不需要等待前一个请求或响应完成。这种机制被称为多路复用，它可以显著地提高网络的利用率和性能。

每个 HTTP/2 流都有一个状态，包括 idle、open、half-closed（local）、half-closed（remote）、closed 等。流的状态会随着帧（Frame）的发送和接收而改变。例如，当一个流收到一个包含 END_STREAM 标志的帧时，它的状态会变为 half-closed。

此外，HTTP/2 还引入了流控制（Flow Control）机制，可以防止发送方过快地发送数据，导致接收方无法处理。流控制是在每个流的基础上进行的，也就是说，每个流都有自己的流控制窗口。

type clientStream struct {
  // 表示这个流所属的客户端连接
	cc *ClientConn

	// Fields of Request that we may access even after the response body is closed.
  // 分别表示请求的上下文和请求的取消通道
	ctx       context.Context
	reqCancel <-chan struct{}

  // 追踪http请求的生命周期
	trace         *httptrace.ClientTrace // or nil
  // 流ID
	ID            uint32
  // 带缓冲的管道，用于存储流控制的响应负载
	bufPipe       pipe 
  // 表示是否请求了 Gzip 压缩
	requestedGzip bool
  // 表示是否是 HEAD 请求
	isHead        bool

  // 用于表示流是否应该立即结束
	abortOnce sync.Once
	abort     chan struct{} // closed to signal stream should end immediately
	abortErr  error         // set if abort is closed

  // 这两个通道分别在对端发送 END_STREAM 标志和流进入关闭状态后关闭
	peerClosed chan struct{} 
	donec      chan struct{} 
  
  // 缓冲通道，如果收到 100 响应，会写入这个通道
	on100      chan struct{}

  // 两个字段分别表示是否收到了响应头和响应
	respHeaderRecv chan struct{}  
	res            *http.Response

  // 表示出流和入流的流量控制
	flow        outflow // guarded by cc.mu
	inflow      inflow  // guarded by cc.mu
  
  // 分别表示剩余的字节数和读取错误
	bytesRemain int64   // -1 means unknown; owned by transportResponseBody.Read
	readErr     error   // sticky read error; owned by transportResponseBody.Read

  // 表示请求体、请求体的内容长度和请求体的关闭通道
	reqBody              io.ReadCloser
	reqBodyContentLength int64         // -1 means unknown
	reqBodyClosed        chan struct{} // guarded by cc.mu; non-nil on Close, closed when done

  // 表示是否向对端发送了 END_STREAM 标志和头部。
	// owned by writeRequest:
	sentEndStream bool
	sentHeaders   bool

  // 这些字段表示读取循环的状态
	// owned by clientConnReadLoop:
	firstByte    bool  // got the first response byte
	pastHeaders  bool  // got first MetaHeadersFrame (actual headers)
	pastTrailers bool  // got optional second MetaHeadersFrame (trailers)
	num1xx       uint8 // number of 1xx responses seen
	readClosed   bool  // peer sent an END_STREAM flag
	readAborted  bool  // read loop reset the stream

  // 表示累积的尾部和客户端的响应尾部
	trailer    http.Header  // accumulated trailers
	resTrailer *http.Header // client's Response.Trailer
}

客户端发起请求

客户端发起请求分为两部分：数据读取与处理工作交给了连接的读循环goroutine，而发起请求则交由流执行

无论是读响应还是写请求都是通过客户端连接中帧处理器所属的网络连接中获取的。

一个客户端连接对应一个网络连接，一个客户端连接对应多个流，而一个请求对应一个流。

客户端连接通过判断是否超出最大并发流限制去创建新流处理，一个请求通过是否有可复用的客户端连接来判断是否要重新创建，而流是不能被复用的

整个客户端请求流程如下

1. 尝试在连接池中获取可复用的连接

2. 如不能，则创建新的客户端连接，建立网络连接，并设置初始参数

   客户端连接在创建之后，开启新协程，从帧处理器循环读取帧，流的缓存管道绑定响应体后，数据被添加到对应流的缓存管道中。

3. 开启新流，写入请求到对应客户端连接的帧处理器缓冲区中，并在接收到响应头后更新响应的请求、TLS等信息

// RoundTripOpt is like RoundTrip, but takes options.
func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) {
  // 检查请求的url是否支持http2
	if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) {
		return nil, errors.New("http2: unsupported scheme")
	}

  // 尝试获取连接
	addr := authorityAddr(req.URL.Scheme, req.URL.Host)
	for retry := 0; ; retry++ {
		cc, err := t.connPool().GetClientConn(req, addr)
		if err != nil {
			t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err)
			return nil, err
		}
		reused := !atomic.CompareAndSwapUint32(&cc.reused, 0, 1)
		traceGotConn(req, cc, reused)
    
    // 客户端连接发起请求
		res, err := cc.RoundTrip(req)
    
    // 若发生错误最多重试6次
		if err != nil && retry <= 6 {
			roundTripErr := err
			if req, err = shouldRetryRequest(req, err); err == nil {
				// After the first retry, do exponential backoff with 10% jitter.
				if retry == 0 {
					t.vlogf("RoundTrip retrying after failure: %v", roundTripErr)
					continue
				}
        
        // 对重试间隔进行指数回退
				backoff := float64(uint(1) << (uint(retry) - 1))
				backoff += backoff * (0.1 * mathrand.Float64())
				d := time.Second * time.Duration(backoff)
        
        // 等待重试间隔时间
				var tm timer
				if t.syncHooks != nil {
					// ... syncHooks block
				} else {
					tm = newTimeTimer(d)
				}
				select {
				case <-tm.C():
					t.vlogf("RoundTrip retrying after failure: %v", roundTripErr)
					continue
				case <-req.Context().Done():
					tm.Stop()
					err = req.Context().Err()
				}
			}
		}
    
    // 超过重试次数返回错误
		if err != nil {
			t.vlogf("RoundTrip failure: %v", err)
			return nil, err
		}
		return res, nil
	}
}

客户端连接获取

尝试先从连接池获取客户端连接，若不存在则拨号建立新连接，并启动协程读取处理数据

那么在什么情况下会创建新连接呢？

• 请求独占连接且设置了dialOnMiss(一般都会设置)

• 连接池中不存在已经建立的连接，或者连接不能再承载新请求了（比如已经创建的流数量+等待的请求*2已经超过了int32的最大值）

func (p *clientConnPool) getClientConn(req *http.Request, addr string, dialOnMiss bool) (*ClientConn, error) {
	// TODO(dneil): Dial a new connection when t.DisableKeepAlives is set?
  // 若请求为完成后关闭其连接且允许缺失时拨号，则创建新的连接返回
  // 由于是一个请求独占的连接，所以该连接不通过连接池创建、管理
	if isConnectionCloseRequest(req) && dialOnMiss {
		// It gets its own connection.
		traceGetConn(req, addr)
		const singleUse = true
		cc, err := p.t.dialClientConn(req.Context(), addr, singleUse)
		if err != nil {
			return nil, err
		}
		return cc, nil
	}
  
  
	for {
    // 遍历连接池中指定地址的连接列表，查找是否有可用的连接。如果找到可用的连接，则标记它为已经被新请求占用，然后返回该连接
		p.mu.Lock()
		for _, cc := range p.conns[addr] {
      // 判断是否能创建新请求，并预留并发流（防止连接被关闭）
			if cc.ReserveNewRequest() {
				// When a connection is presented to us by the net/http package,
				// the GetConn hook has already been called.
				// Don't call it a second time here.
				if !cc.getConnCalled {
					traceGetConn(req, addr)
				}
				cc.getConnCalled = false
				p.mu.Unlock()
				return cc, nil
			}
		}
    
    // 如果连接池中没有可用的连接，并且不允许在缺失时拨号，则返回错误 
		if !dialOnMiss {
			p.mu.Unlock()
			return nil, ErrNoCachedConn
		}
    
		traceGetConn(req, addr)
    
    // 连接池中拨号创建连接
		call := p.getStartDialLocked(req.Context(), addr)
		p.mu.Unlock()
		<-call.done
		if shouldRetryDial(call, req) {
			continue
		}
		cc, err := call.res, call.err
		if err != nil {
			return nil, err
		}
    
    // 如果拨号调用成功，且连接可以被新请求占用，则返回该连接
		if cc.ReserveNewRequest() {
			return cc, nil
		}
	}
}

创建新客户端连接

无论是通过连接池创建新连接还是直接创建都要通过newClientConn方法去实现

func (t *Transport) newClientConn(c net.Conn, singleUse bool, hooks *testSyncHooks) (*ClientConn, error) {
	cc := &ClientConn{
		t:                     t,
		tconn:                 c,
		readerDone:            make(chan struct{}),
		nextStreamID:          1,
		maxFrameSize:          16 << 10,                    // spec default
		initialWindowSize:     65535,                       // spec default
		maxConcurrentStreams:  initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings.
		peerMaxHeaderListSize: 0xffffffffffffffff,          // "infinite", per spec. Use 2^64-1 instead.
		streams:               make(map[uint32]*clientStream),
		singleUse:             singleUse,
		wantSettingsAck:       true,
		pings:                 make(map[[8]byte]chan struct{}),
		reqHeaderMu:           make(chan struct{}, 1),
		syncHooks:             hooks,
	}
	if hooks != nil {
		hooks.newclientconn(cc)
		c = cc.tconn
	}
  
  // 若存在空闲超时，则在超时之后关闭空闲连接
	if d := t.idleConnTimeout(); d != 0 {
		cc.idleTimeout = d
		cc.idleTimer = cc.afterFunc(d, cc.onIdleTimeout)
	}
	if VerboseLogs {
		t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr())
	}

  // 为流量控制设置初始窗口大小
	cc.cond = sync.NewCond(&cc.mu)
	cc.flow.add(int32(initialWindowSize))

  // 创建一个带有错误处理的缓冲写入器 cc.bw 和一个缓冲读取器 cc.br
	// TODO: adjust this writer size to account for frame size +
	// MTU + crypto/tls record padding.
	cc.bw = bufio.NewWriter(stickyErrWriter{
		conn:    c,
		timeout: t.WriteByteTimeout,
		err:     &cc.werr,
	})
	cc.br = bufio.NewReader(c)
  
  // 创建一个新的帧处理器 cc.fr，并设置最大帧读取大小、错误计数器、设置最大头部列表大小
	cc.fr = NewFramer(cc.bw, cc.br)
	if t.maxFrameReadSize() != 0 {
		cc.fr.SetMaxReadFrameSize(t.maxFrameReadSize())
	}
	if t.CountError != nil {
		cc.fr.countError = t.CountError
	}
	maxHeaderTableSize := t.maxDecoderHeaderTableSize()
	cc.fr.ReadMetaHeaders = hpack.NewDecoder(maxHeaderTableSize, nil)
	cc.fr.MaxHeaderListSize = t.maxHeaderListSize()

	cc.henc = hpack.NewEncoder(&cc.hbuf)
	cc.henc.SetMaxDynamicTableSizeLimit(t.maxEncoderHeaderTableSize())
	cc.peerMaxHeaderTableSize = initialHeaderTableSize

  // 如果允许 HTTP/1.1 升级到 HTTP/2，设置下一个流 ID 为 3
	if t.AllowHTTP {
		cc.nextStreamID = 3
	}

  // 如果连接支持获取连接状态，保存 TLS 连接状态
	if cs, ok := c.(connectionStater); ok {
		state := cs.ConnectionState()
		cc.tlsState = &state
	}

  // 创建初始设置列表，包括禁用服务器推送、设置初始窗口大小、最大帧大小、最大头部列表大小和头部表大小。
	initialSettings := []Setting{
		{ID: SettingEnablePush, Val: 0},
		{ID: SettingInitialWindowSize, Val: transportDefaultStreamFlow},
	}
	if max := t.maxFrameReadSize(); max != 0 {
		initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: max})
	}
	if max := t.maxHeaderListSize(); max != 0 {
		initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max})
	}
	if maxHeaderTableSize != initialHeaderTableSize {
		initialSettings = append(initialSettings, Setting{ID: SettingHeaderTableSize, Val: maxHeaderTableSize})
	}

  // 写入客户端前缀和初始设置，更新窗口大小，初始化输入流控制，并刷新写入器
	cc.bw.Write(clientPreface)
	cc.fr.WriteSettings(initialSettings...)
	cc.fr.WriteWindowUpdate(0, transportDefaultConnFlow)
	cc.inflow.init(transportDefaultConnFlow + initialWindowSize)
	cc.bw.Flush()
	if cc.werr != nil {
		cc.Close()
		return nil, cc.werr
	}

  // 启动循环读取
	cc.goRun(cc.readLoop)
	return cc, nil
}

连接数据读取与处理

客户端连接上运行读取循环，不断读取并处理帧

依然是一个连接一个协程读取处理

GOAWAY帧: 启动连接关闭或发出严重错误信号。允许端点正常停止接受新的流，同时仍然完成对先前建立的流的处理。这可以实现管理操作，例如服务器维护

PUSH_PROMISE帧: 请求允许服务端开启新流推送。客户端可能选择通过发送RST_STRWAM帧拒绝

// readLoop runs in its own goroutine and reads and dispatches frames.
func (cc *ClientConn) readLoop() {
	rl := &clientConnReadLoop{cc: cc}
	defer rl.cleanup()
	cc.readerErr = rl.run()
	if ce, ok := cc.readerErr.(ConnectionError); ok {
		cc.wmu.Lock()
		cc.fr.WriteGoAway(0, ErrCode(ce), nil)
		cc.wmu.Unlock()
	}
}

func (rl *clientConnReadLoop) run() error {
	cc := rl.cc
	gotSettings := false
  // 根据配置读取空闲超时时间，并启动定时器
	readIdleTimeout := cc.t.ReadIdleTimeout
	var t timer
	if readIdleTimeout != 0 {
		t = cc.afterFunc(readIdleTimeout, cc.healthCheck)
	}
	for {
    // 读取帧
		f, err := cc.fr.ReadFrame()
		if t != nil {
			t.Reset(readIdleTimeout)
		}
		if err != nil {
			cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err)
		}
		if se, ok := err.(StreamError); ok {
			if cs := rl.streamByID(se.StreamID); cs != nil {
				if se.Cause == nil {
					se.Cause = cc.fr.errDetail
				}
				rl.endStreamError(cs, se)
			}
			continue
		} else if err != nil {
			cc.countReadFrameError(err)
			return err
		}
		if VerboseLogs {
			cc.vlogf("http2: Transport received %s", summarizeFrame(f))
		}
		if !gotSettings {
			if _, ok := f.(*SettingsFrame); !ok {
				cc.logf("protocol error: received %T before a SETTINGS frame", f)
				return ConnectionError(ErrCodeProtocol)
			}
			gotSettings = true
		}

		switch f := f.(type) {
      // 处理头部帧
		case *MetaHeadersFrame:
			err = rl.processHeaders(f)
      // 处理数据帧
		case *DataFrame:
			err = rl.processData(f)
      // 处理GOAWAY帧
		case *GoAwayFrame:
			err = rl.processGoAway(f)
      // 处理RST_STREAM 帧
		case *RSTStreamFrame:
			err = rl.processResetStream(f)
      // 处理 SETTINGS 帧
		case *SettingsFrame:
			err = rl.processSettings(f)
      // 处理 PUSH_PROMISE 帧
		case *PushPromiseFrame:
			err = rl.processPushPromise(f)
      // 处理 WINDOW_UPDATE 帧
		case *WindowUpdateFrame:
			err = rl.processWindowUpdate(f)
      // 处理 PING 帧
		case *PingFrame:
			err = rl.processPing(f)
		default:
			cc.logf("Transport: unhandled response frame type %T", f)
		}
		if err != nil {
			if VerboseLogs {
				cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, summarizeFrame(f), err)
			}
			return err
		}
	}
}

处理头部帧

func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error {
  // 根据帧中的流ID获取对应的客户端流
	cs := rl.streamByID(f.StreamID)
	if cs == nil {
    // 客户端取消请求，而服务端仍然在响应中，此时可忽略
		return nil
	}
  
  // 检查客户端流是否已经关闭读取，如果是，则说明协议错误，返回协议错误
	if cs.readClosed {
		rl.endStreamError(cs, StreamError{
			StreamID: f.StreamID,
			Code:     ErrCodeProtocol,
			Cause:    errors.New("protocol error: headers after END_STREAM"),
		})
		return nil
	}
  
  // 如果客户端流尚未接收到第一个字节，记录该字节已经接收到，并触发首个响应字节事件
	if !cs.firstByte {
		if cs.trace != nil {
			traceFirstResponseByte(cs.trace)
		}
		cs.firstByte = true
	}
  
  // 如果还未收到header帧，则设置已经收到
  // 否则，处理trailer
	if !cs.pastHeaders {
		cs.pastHeaders = true
	} else {
		return rl.processTrailers(cs, f)
	}

  // 处理响应
	res, err := rl.handleResponse(cs, f)
	if err != nil {
		if _, ok := err.(ConnectionError); ok {
			return err
		}
		// Any other error type is a stream error.
		rl.endStreamError(cs, StreamError{
			StreamID: f.StreamID,
			Code:     ErrCodeProtocol,
			Cause:    err,
		})
		return nil // return nil from process* funcs to keep conn alive
	}
	if res == nil {
		// (nil, nil) special case. See handleResponse docs.
		return nil
	}
  
  // 设置流的响应trailer、响应体，并释放流头部接收结束信号
	cs.resTrailer = &res.Trailer
	cs.res = res
	close(cs.respHeaderRecv)
  
  // 如果头部帧标志着流的结束，则结束流
	if f.StreamEnded() {
		rl.endStream(cs)
	}
	return nil
}

实际头部帧的处理放在了handleResponse方法

// may return error types nil, or ConnectionError. Any other error value
// is a StreamError of type ErrCodeProtocol. The returned error in that case
// is the detail.
//
// As a special case, handleResponse may return (nil, nil) to skip the
// frame (currently only used for 1xx responses).
func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFrame) (*http.Response, error) {
  // 检查头部帧是否截断，如果截断，则返回响应头部列表大小错误
	if f.Truncated {
		return nil, errResponseHeaderListSize
	}

  // 解析伪头部字段，获取响应状态码
	status := f.PseudoValue("status")
	if status == "" {
		return nil, errors.New("malformed response from server: missing status pseudo header")
	}
	statusCode, err := strconv.Atoi(status)
	if err != nil {
		return nil, errors.New("malformed response from server: malformed non-numeric status pseudo header")
	}

  // 构建 http.Response 对象，设置协议版本、状态码、状态文本等基本信息
	regularFields := f.RegularFields()
	strs := make([]string, len(regularFields))
	header := make(http.Header, len(regularFields))
	res := &http.Response{
		Proto:      "HTTP/2.0",
		ProtoMajor: 2,
		Header:     header,
		StatusCode: statusCode,
		Status:     status + " " + http.StatusText(statusCode),
	}
  
  // 遍历常规头部字段，填充到响应头部中，同时处理 Trailer 头部字段
	for _, hf := range regularFields {
		key := canonicalHeader(hf.Name)
		if key == "Trailer" {
			t := res.Trailer
			if t == nil {
				t = make(http.Header)
				res.Trailer = t
			}
			foreachHeaderElement(hf.Value, func(v string) {
				t[canonicalHeader(v)] = nil
			})
		} else {
			vv := header[key]
			if vv == nil && len(strs) > 0 {
				// More than likely this will be a single-element key.
				// Most headers aren't multi-valued.
				// Set the capacity on strs[0] to 1, so any future append
				// won't extend the slice into the other strings.
				vv, strs = strs[:1:1], strs[1:]
				vv[0] = hf.Value
				header[key] = vv
			} else {
				header[key] = append(vv, hf.Value)
			}
		}
	}

  // 如果状态码是 1xx 信息响应，则根据不同状态码进行相应处理
	if statusCode >= 100 && statusCode <= 199 {
		if f.StreamEnded() {
			return nil, errors.New("1xx informational response with END_STREAM flag")
		}
		cs.num1xx++
		const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http
		if cs.num1xx > max1xxResponses {
			return nil, errors.New("http2: too many 1xx informational responses")
		}
		if fn := cs.get1xxTraceFunc(); fn != nil {
			if err := fn(statusCode, textproto.MIMEHeader(header)); err != nil {
				return nil, err
			}
		}
    // 100状态码代表服务器暂时接受了客户端的请求，并期望客户端继续发送请求数据
		if statusCode == 100 {
			traceGot100Continue(cs.trace)
			select {
			case cs.on100 <- struct{}{}:
			default:
			}
		}
		cs.pastHeaders = false // do it all again
		return nil, nil
	}

  // 如果状态码不是 1xx 信息响应，则设置响应的内容长度（如果存在）
	res.ContentLength = -1
	if clens := res.Header["Content-Length"]; len(clens) == 1 {
		if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil {
			res.ContentLength = int64(cl)
		} else {
			// TODO: care? unlike http/1, it won't mess up our framing, so it's
			// more safe smuggling-wise to ignore.
		}
	} else if len(clens) > 1 {
		// TODO: care? unlike http/1, it won't mess up our framing, so it's
		// more safe smuggling-wise to ignore.
	} else if f.StreamEnded() && !cs.isHead {
		res.ContentLength = 0
	}

  // 若为head请求，则设置响应体为空
	if cs.isHead {
		res.Body = noBody
		return res, nil
	}

  // 如果响应头部帧已经结束，并且响应体不是空的，则设置响应体为 missingBody
	if f.StreamEnded() {
		if res.ContentLength > 0 {
			res.Body = missingBody{}
		} else {
			res.Body = noBody
		}
		return res, nil
	}

  // 否则，根据是否请求了 gzip 压缩，对响应体进行处理，并返回响应
	cs.bufPipe.setBuffer(&dataBuffer{expected: res.ContentLength})
	cs.bytesRemain = res.ContentLength
  // 将流的缓存管道绑定到响应体中，读取响应体，其实就是读取流的缓存管道
	res.Body = transportResponseBody{cs}

	if cs.requestedGzip && asciiEqualFold(res.Header.Get("Content-Encoding"), "gzip") {
		res.Header.Del("Content-Encoding")
		res.Header.Del("Content-Length")
		res.ContentLength = -1
		res.Body = &gzipReader{body: res.Body}
		res.Uncompressed = true
	}
	return res, nil
}

处理数据帧

func (rl *clientConnReadLoop) processData(f *DataFrame) error {
  // 获取帧对应客户端流
	cc := rl.cc
	cs := rl.streamByID(f.StreamID)
	data := f.Data()
  
  // 若无对应流，则返回协议错误，或者直接忽略
	if cs == nil {
		cc.mu.Lock()
		neverSent := cc.nextStreamID
		cc.mu.Unlock()
    // 若为未创建的流ID，则返回协议错误
		if f.StreamID >= neverSent {
			// We never asked for this.
			cc.logf("http2: Transport received unsolicited DATA frame; closing connection")
			return ConnectionError(ErrCodeProtocol)
		}
    
    // 如果数据帧包含有效载荷，在流量控制不允许时，返回流量控制错误
    // 否则更新流量控制窗口，并返回
		if f.Length > 0 {
			cc.mu.Lock()
			ok := cc.inflow.take(f.Length)
			connAdd := cc.inflow.add(int(f.Length))
			cc.mu.Unlock()
			if !ok {
				return ConnectionError(ErrCodeFlowControl)
			}
			if connAdd > 0 {
				cc.wmu.Lock()
				cc.fr.WriteWindowUpdate(0, uint32(connAdd))
				cc.bw.Flush()
				cc.wmu.Unlock()
			}
		}
		return nil
	}
  
  // 如果客户端流已关闭，则记录协议错误并结束该流
	if cs.readClosed {
		cc.logf("protocol error: received DATA after END_STREAM")
		rl.endStreamError(cs, StreamError{
			StreamID: f.StreamID,
			Code:     ErrCodeProtocol,
		})
		return nil
	}
  
  // 确保已接收到相应的头部帧（HEADERS frame）。如果还未接收到头部帧，则记录协议错误并结束该流
	if !cs.pastHeaders {
		cc.logf("protocol error: received DATA before a HEADERS frame")
		rl.endStreamError(cs, StreamError{
			StreamID: f.StreamID,
			Code:     ErrCodeProtocol,
		})
		return nil
	}
  
  // 检查是否收到了数据帧（DATA frame）在HEAD请求上的响应。如果是，则记录协议错误并结束该流
	if f.Length > 0 {
		if cs.isHead && len(data) > 0 {
			cc.logf("protocol error: received DATA on a HEAD request")
			rl.endStreamError(cs, StreamError{
				StreamID: f.StreamID,
				Code:     ErrCodeProtocol,
			})
			return nil
		}
    
    // 处理连接级别和流级别的流量控制。首先，它尝试从连接级别的流量窗口中减去相应的字节数，然后尝试从流级别的流量窗口中减去相应的字节数。如果减去流级别的字节数后流量窗口小于零，会返回流量控制错误。同时，如果数据帧中有填充字段，会在此时退还填充字段的流量窗口
		// Check connection-level flow control.
		cc.mu.Lock()
		if !takeInflows(&cc.inflow, &cs.inflow, f.Length) {
			cc.mu.Unlock()
			return ConnectionError(ErrCodeFlowControl)
		}
		// Return any padded flow control now, since we won't
		// refund it later on body reads.
		var refund int
		if pad := int(f.Length) - len(data); pad > 0 {
			refund += pad
		}

    // 将数据写入客户端流的缓冲管道中，并根据需要发送窗口更新帧
		didReset := false
		var err error
		if len(data) > 0 {
			if _, err = cs.bufPipe.Write(data); err != nil {
				// Return len(data) now if the stream is already closed,
				// since data will never be read.
				didReset = true
				refund += len(data)
			}
		}

		sendConn := cc.inflow.add(refund)
		var sendStream int32
		if !didReset {
			sendStream = cs.inflow.add(refund)
		}
		cc.mu.Unlock()

		if sendConn > 0 || sendStream > 0 {
			cc.wmu.Lock()
			if sendConn > 0 {
				cc.fr.WriteWindowUpdate(0, uint32(sendConn))
			}
			if sendStream > 0 {
				cc.fr.WriteWindowUpdate(cs.ID, uint32(sendStream))
			}
			cc.bw.Flush()
			cc.wmu.Unlock()
		}

		if err != nil {
			rl.endStreamError(cs, err)
			return nil
		}
	}

	if f.StreamEnded() {
		rl.endStream(cs)
	}
	return nil
}

流请求处理

发起协程去请求，主流程等待连接处理header后，向响应写入请求、TLS

func (cc *ClientConn) roundTrip(req *http.Request, streamf func(*clientStream)) (*http.Response, error) {
	ctx := req.Context()
  // 创建clientStream对象用于跟踪请求和响应状态
	cs := &clientStream{
		cc:                   cc,
		ctx:                  ctx,
		reqCancel:            req.Cancel,
		isHead:               req.Method == "HEAD",
		reqBody:              req.Body,
		reqBodyContentLength: actualContentLength(req),
		trace:                httptrace.ContextClientTrace(ctx),
		peerClosed:           make(chan struct{}),
		abort:                make(chan struct{}),
		respHeaderRecv:       make(chan struct{}),
		donec:                make(chan struct{}),
	}
  
  // 异步发送http请求
	cc.goRun(func() {
		cs.doRequest(req)
	})

  // 等待请求完成、取消以及响应头部接收完成，然后处理响应头部
	waitDone := func() error {
    // ... syncHooks的等待
    
		select {
		case <-cs.donec:
			return nil
		case <-ctx.Done():
			return ctx.Err()
		case <-cs.reqCancel:
			return errRequestCanceled
		}
	}

  // 处理响应头部。
	handleResponseHeaders := func() (*http.Response, error) {
		res := cs.res
    // 若响应状态码超过299，则放弃请求体写入
		if res.StatusCode > 299 {
			cs.abortRequestBodyWrite()
		}
    
    // 更新响应的请求、TLS等信息
		res.Request = req
		res.TLS = cc.tlsState
    
    // 若请求体为空且响应体未被写入，则等待流被关闭
		if res.Body == noBody && actualContentLength(req) == 0 {
			if err := waitDone(); err != nil {
				return nil, err
			}
		}
		return res, nil
	}

  // 取消请求
	cancelRequest := func(cs *clientStream, err error) error {
		cs.cc.mu.Lock()
		bodyClosed := cs.reqBodyClosed
		cs.cc.mu.Unlock()

		if bodyClosed != nil {
			<-bodyClosed
		}
		return err
	}

	if streamf != nil {
		streamf(cs)
	}

	for {
		// ... syncHooks block
    
    // 等待事件发生并处理
		select {
      // 接收到响应头
		case <-cs.respHeaderRecv:
			return handleResponseHeaders()
      // 流被中止
		case <-cs.abort:
			select {
			case <-cs.respHeaderRecv:
				// If both cs.respHeaderRecv and cs.abort are signaling,
				// pick respHeaderRecv. The server probably wrote the
				// response and immediately reset the stream.
				// golang.org/issue/49645
				return handleResponseHeaders()
			default:
				waitDone()
				return nil, cs.abortErr
			}
      // 上下文被取消
		case <-ctx.Done():
			err := ctx.Err()
			cs.abortStream(err)
			return nil, cancelRequest(cs, err)
      
      // 请求被取消
		case <-cs.reqCancel:
			cs.abortStream(errRequestCanceled)
			return nil, cancelRequest(cs, errRequestCanceled)
		}
	}
}

发送请求

在流发送请求时，除了将请求写入帧，同时还会向连接获取流的开放槽位，以及分配新流ID

值得注意的是streamID每次递增2，这是因为客户端发起的流ID为奇数，服务端发起的流ID为偶数。

// doRequest运行在请求整个生命周期中
// 发送请求并执行请求后清理
func (cs *clientStream) doRequest(req *http.Request) {
	err := cs.writeRequest(req)
	cs.cleanupWriteRequest(err)
}

// writeRequest sends a request.
//
// It returns nil after the request is written, the response read,
// and the request stream is half-closed by the peer.
//
// It returns non-nil if the request ends otherwise.
// If the returned error is StreamError, the error Code may be used in resetting the stream.
func (cs *clientStream) writeRequest(req *http.Request) (err error) {
	cc := cs.cc
	ctx := cs.ctx

  // 检查请求头是否有效
	if err := checkConnHeaders(req); err != nil {
		return err
	}

	if cc.reqHeaderMu == nil {
		panic("RoundTrip on uninitialized ClientConn") // for tests
	}
	var newStreamHook func(*clientStream)
	
  // ... syncHooks block
  
	select {
    // 标记正在写入连接
	case cc.reqHeaderMu <- struct{}{}:
	case <-cs.reqCancel:
		return errRequestCanceled
	case <-ctx.Done():
		return ctx.Err()
	}

	cc.mu.Lock()
  // 该连接即将被用于发送请求，不再空闲
	if cc.idleTimer != nil {
		cc.idleTimer.Stop()
	}
  
  // 减少当前连接的流数量，确保不会超过限制
	cc.decrStreamReservationsLocked()
  
  // 检查连接当前是否超出最大并发流限制
  // 超过则等待
	if err := cc.awaitOpenSlotForStreamLocked(cs); err != nil {
		cc.mu.Unlock()
		<-cc.reqHeaderMu
		return err
	}
  
  // 分配新流ID
	cc.addStreamLocked(cs)
  
  // 如果请求标记为关闭连接，则将 ClientConn 的 doNotReuse 标志设置为 true，表示不再重用这个连接。
	if isConnectionCloseRequest(req) {
		cc.doNotReuse = true
	}
	cc.mu.Unlock()

	if newStreamHook != nil {
		newStreamHook(cs)
	}

  // 设置gzip编码
	if !cc.t.disableCompression() &&
		req.Header.Get("Accept-Encoding") == "" &&
		req.Header.Get("Range") == "" &&
		!cs.isHead {
		// Request gzip only, not deflate. Deflate is ambiguous and
		// not as universally supported anyway.
		// See: https://zlib.net/zlib_faq.html#faq39
		//
		// Note that we don't request this for HEAD requests,
		// due to a bug in nginx:
		//   http://trac.nginx.org/nginx/ticket/358
		//   https://golang.org/issue/5522
		//
		// We don't request gzip if the request is for a range, since
		// auto-decoding a portion of a gzipped document will just fail
		// anyway. See https://golang.org/issue/8923
		cs.requestedGzip = true
	}

	continueTimeout := cc.t.expectContinueTimeout()
	if continueTimeout != 0 {
		if !httpguts.HeaderValuesContainsToken(req.Header["Expect"], "100-continue") {
			continueTimeout = 0
		} else {
			cs.on100 = make(chan struct{}, 1)
		}
	}

  // 编码并发送请求头
	err = cs.encodeAndWriteHeaders(req)
	<-cc.reqHeaderMu
	if err != nil {
		return err
	}

	hasBody := cs.reqBodyContentLength != 0
	if !hasBody {
		cs.sentEndStream = true
	} else {
		if continueTimeout != 0 {
			traceWait100Continue(cs.trace)
			timer := time.NewTimer(continueTimeout)
			select {
			case <-timer.C:
				err = nil
			case <-cs.on100:
				err = nil
			case <-cs.abort:
				err = cs.abortErr
			case <-ctx.Done():
				err = ctx.Err()
			case <-cs.reqCancel:
				err = errRequestCanceled
			}
   
			timer.Stop()
			if err != nil {
				traceWroteRequest(cs.trace, err)
				return err
			}
		}

    // 发送请求体，成功之后设置流发送完成
		if err = cs.writeRequestBody(req); err != nil {
			if err != errStopReqBodyWrite {
				traceWroteRequest(cs.trace, err)
				return err
			}
		} else {
			cs.sentEndStream = true
		}
	}

	traceWroteRequest(cs.trace, err)

	var respHeaderTimer <-chan time.Time
	var respHeaderRecv chan struct{}
	if d := cc.responseHeaderTimeout(); d != 0 {
		timer := cc.newTimer(d)
		defer timer.Stop()
		respHeaderTimer = timer.C()
		respHeaderRecv = cs.respHeaderRecv
	}
	// Wait until the peer half-closes its end of the stream,
	// or until the request is aborted (via context, error, or otherwise),
	// whichever comes first.
	for {
		// ... syncHooks block
    
		select {
		case <-cs.peerClosed:
			return nil
      // 等待响应头超时后，返回超时错误
		case <-respHeaderTimer:
			return errTimeout
		case <-respHeaderRecv:
			respHeaderRecv = nil
			respHeaderTimer = nil // keep waiting for END_STREAM
		case <-cs.abort:
			return cs.abortErr
		case <-ctx.Done():
			return ctx.Err()
		case <-cs.reqCancel:
			return errRequestCanceled
		}
	}
}

写入请求体

将请求体数据写入帧缓冲区，并刷新

func (cs *clientStream) writeRequestBody(req *http.Request) (err error) {
	cc := cs.cc
	body := cs.reqBody
	sentEnd := false // whether we sent the final DATA frame w/ END_STREAM

	hasTrailers := req.Trailer != nil
	remainLen := cs.reqBodyContentLength
	hasContentLen := remainLen != -1

	cc.mu.Lock()
	maxFrameSize := int(cc.maxFrameSize)
	cc.mu.Unlock()

  // 获取临时缓冲区
  // 先尝试从缓冲区池中获取相应长度的缓冲，不然就重新分配
	scratchLen := cs.frameScratchBufferLen(maxFrameSize)
	var buf []byte
	index := bufPoolIndex(scratchLen)
	if bp, ok := bufPools[index].Get().(*[]byte); ok && len(*bp) >= scratchLen {
		defer bufPools[index].Put(bp)
		buf = *bp
	} else {
		buf = make([]byte, scratchLen)
		defer bufPools[index].Put(&buf)
	}

	var sawEOF bool
	for !sawEOF {
    // 从请求体中读取数据
		n, err := body.Read(buf)
		if hasContentLen {
			remainLen -= int64(n)
      // 确保数据输出完整，或者避免未按照预期结束引发问题
			if remainLen == 0 && err == nil {
				var scratch [1]byte
				var n1 int
				n1, err = body.Read(scratch[:])
				remainLen -= int64(n1)
			}
			if remainLen < 0 {
				err = errReqBodyTooLong
				return err
			}
		}
    // 根据读取到的错误，做相应处理
		if err != nil {
			cc.mu.Lock()
			bodyClosed := cs.reqBodyClosed != nil
			cc.mu.Unlock()
			switch {
			case bodyClosed:
				return errStopReqBodyWrite
			case err == io.EOF:
				sawEOF = true
				err = nil
			default:
				return err
			}
		}

    // 等待从服务端获取流量控制的允许字节数，并根据该数发送相应的请求数据
		remain := buf[:n]
		for len(remain) > 0 && err == nil {
			var allowed int32
			allowed, err = cs.awaitFlowControl(len(remain))
			if err != nil {
				return err
			}
			cc.wmu.Lock()
			data := remain[:allowed]
			remain = remain[allowed:]
			sentEnd = sawEOF && len(remain) == 0 && !hasTrailers
			err = cc.fr.WriteData(cs.ID, sentEnd, data)
			if err == nil {
				err = cc.bw.Flush()
			}
			cc.wmu.Unlock()
		}
		if err != nil {
			return err
		}
	}

  // 若请求数据发送完毕且无trailer，则直接返回
	if sentEnd {
		return nil
	}

   // 如果trailer不为空，则发送带trailer的请求结束帧
  // 若不需要trailer，则发送空的END_STREAM 帧
	cc.mu.Lock()
	trailer := req.Trailer
	err = cs.abortErr
	cc.mu.Unlock()
	if err != nil {
		return err
	}

	cc.wmu.Lock()
	defer cc.wmu.Unlock()
	var trls []byte
	if len(trailer) > 0 {
		trls, err = cc.encodeTrailers(trailer)
		if err != nil {
			return err
		}
	}

	// Two ways to send END_STREAM: either with trailers, or
	// with an empty DATA frame.
	if len(trls) > 0 {
		err = cc.writeHeaders(cs.ID, true, maxFrameSize, trls)
	} else {
		err = cc.fr.WriteData(cs.ID, true, nil)
	}
	if ferr := cc.bw.Flush(); ferr != nil && err == nil {
		err = ferr
	}
	return err
}

向framer内部缓冲区写入带填充的Data帧，但并不将帧立即刷新到底层writer。

之后被流刷新到底层writer，也就是网络连接

func (f *Framer) startWriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error {
  // 检查流ID是否合法
	if !validStreamID(streamID) && !f.AllowIllegalWrites {
		return errStreamID
	}
  
  // 检查填充是否合法
	if len(pad) > 0 {
		if len(pad) > 255 {
			return errPadLength
		}
		if !f.AllowIllegalWrites {
			for _, b := range pad {
				if b != 0 {
					// "Padding octets MUST be set to zero when sending."
					return errPadBytes
				}
			}
		}
	}
  
  // 设置帧标志位
	var flags Flags
	if endStream {
		flags |= FlagDataEndStream
	}
	if pad != nil {
		flags |= FlagDataPadded
	}
  
  // 指定帧类型为FrameData写入帧header
  // 其实也是写入缓冲区中
	f.startWrite(FrameData, flags, streamID)
	if pad != nil {
		f.wbuf = append(f.wbuf, byte(len(pad)))
	}
  
  // 将数据与填充写入缓冲区
	f.wbuf = append(f.wbuf, data...)
	f.wbuf = append(f.wbuf, pad...)
	return nil
}