// writeQuota is a soft limit on the amount of data a stream can
// schedule before some of it is written out.
type writeQuota struct {
	quota int32
	// get waits on read from when quota goes less than or equal to zero.
	// replenish writes on it when quota goes positive again.
	ch chan struct{}
	// done is triggered in error case.
	done <-chan struct{}
	// replenish is called by loopyWriter to give quota back to.
	// It is implemented as a field so that it can be updated
	// by tests.
	replenish func(n int)
}

// newWriteQuota 用于初始化一个 writeQuota
// sz: 当前可以获取到的 quota 总量
// done: 用于关闭 writeQuota，在外部通过 done 控制 writeQuota 的生命周期
func newWriteQuota(sz int32, done <-chan struct{}) *writeQuota {
	w := &writeQuota{
		quota: sz,
		ch:    make(chan struct{}, 1),
		done:  done,
	}
	w.replenish = w.realReplenish
	return w
}

// get 用于阻塞式获取 sz 数量的 quota
func (w *writeQuota) get(sz int32) error {
	for {
		// 只要 quota > 0，就允许获取，即使获取后 quota < 0。
		if atomic.LoadInt32(&w.quota) > 0 {
			atomic.AddInt32(&w.quota, -sz)
			return nil
		}
		select {
		case <-w.ch:
			continue
		case <-w.done:
			return errStreamDone
		}
	}
}

// realReplenish 用于补充 n 数量的 quota
// 如果补充数量充足，可以解除因数量不足阻塞在 get 处的调用方
func (w *writeQuota) realReplenish(n int) {
	sz := int32(n)
	a := atomic.AddInt32(&w.quota, sz)
	b := a - sz
	if b <= 0 && a > 0 {
		select {
		case w.ch <- struct{}{}:
		default:
		}
	}
}

// Stream represents an RPC in the transport layer.
type Stream struct {
	...
	wq           *writeQuota
	...
}


// defaultWriteQuota is the default value for number of data
// bytes that each stream can schedule before some of it being
// flushed out.
var defaultWriteQuota = 64 * 1024
// 初始化
s.wq = newWriteQuota(defaultWriteQuota, s.ctxDone)


// 放数据之前先从 wq 获取数据大小的 quota 获取成功才允许向 controlBuf 放入数据
func (t *http2Client) Write(s *Stream, hdr []byte, data mem.BufferSlice, opts *Options) error {
	...
	if hdr != nil || df.reader.Remaining() != 0 { // If it's not an empty data frame, check quota.
	 	if err := s.wq.get(int32(len(hdr) + df.reader.Remaining())); err != nil {
	 		_ = reader.Close()
	 		return err
	 	}
	}
	if err := t.controlBuf.put(df); err != nil {
 		_ = reader.Close()
 		return err
 	}
 	return nil
 }


// 当 loopyWriter 成功将数据帧发送出去后，就又会向 writeQuota 补充 quota。
func (l *loopyWriter) processData() (bool, error) {
	...
	str.wq.replenish(size)
	...
}