code: func (ch *Channel) NotifyFlow(c chan bool) chan bool {
  	ch.notifyM.Lock()
  	defer ch.notifyM.Unlock()
  
  	if ch.noNotify {
  		close(c)
  	} else {
  		ch.flows = append(ch.flows, c)
  	}
  
  	return c
  }
docs: /*
  NotifyFlow registers a listener for basic.flow methods sent by the server.
  When `false` is sent on one of the listener channels, all publishers should
  pause until a `true` is sent.
  
  The server may ask the producer to pause or restart the flow of Publishings
  sent by on a channel. This is a simple flow-control mechanism that a server can
  use to avoid overflowing its queues or otherwise finding itself receiving more
  messages than it can process. Note that this method is not intended for window
  control. It does not affect contents returned by basic.get-ok methods.
  
  When a new channel is opened, it is active (flow is active). Some
  applications assume that channels are inactive until started. To emulate
  this behavior a client MAY open the channel, then pause it.
  
  Publishers should respond to a flow messages as rapidly as possible and the
  server may disconnect over producing channels that do not respect these
  messages.
  
  basic.flow-ok methods will always be returned to the server regardless of
  the number of listeners there are.
  
  To control the flow of deliveries from the server, use the Channel.Flow()
  method instead.
  
  Note: RabbitMQ will rather use TCP pushback on the network connection instead
  of sending basic.flow.  This means that if a single channel is producing too
  much on the same connection, all channels using that connection will suffer,
  including acknowledgments from deliveries.  Use different Connections if you
  desire to interleave consumers and producers in the same process to avoid your
  basic.ack messages from getting rate limited with your basic.publish messages.
  
  */