Implement blocking_recv function for broadcast::Receiver

[Slixe]

Is your feature request related to a problem? Please describe.
I would like to be able to block on the Receiver even in an blocking context, not only in async context.

Describe the solution you'd like
Add blocking_recv() function in broadcast::Receiver like its done for others types of Receiver channels.

Describe alternatives you've considered
At this moment, I'm using a try_recv() and a sleep on the Err branch in a loop. A block_on may also be used.

Additional context
I'm creating std threads for faster job I don't want to setup async context for each just for this.

[debadree25]

Hey i would want to give this a try! @Darksonn could you guide on what parts of the code would be relevant for this?

[Darksonn]

Sure. You will need to make your changes in tokio/src/sync/broadcast.rs. You can use the following method from the mpsc channel for inspiration:

tokio/tokio/src/sync/mpsc/bounded.rs

Lines 277 to 332 in 61b68a8

	/// Blocking receive to call outside of asynchronous contexts.
	///
	/// This method returns `None` if the channel has been closed and there are
	/// no remaining messages in the channel's buffer. This indicates that no
	/// further values can ever be received from this `Receiver`. The channel is
	/// closed when all senders have been dropped, or when [`close`] is called.
	///
	/// If there are no messages in the channel's buffer, but the channel has
	/// not yet been closed, this method will block until a message is sent or
	/// the channel is closed.
	///
	/// This method is intended for use cases where you are sending from
	/// asynchronous code to synchronous code, and will work even if the sender
	/// is not using [`blocking_send`] to send the message.
	///
	/// Note that if [`close`] is called, but there are still outstanding
	/// [`Permits`] from before it was closed, the channel is not considered
	/// closed by `blocking_recv` until the permits are released.
	///
	/// [`close`]: Self::close
	/// [`Permits`]: struct@crate::sync::mpsc::Permit
	/// [`blocking_send`]: fn@crate::sync::mpsc::Sender::blocking_send
	///
	/// # Panics
	///
	/// This function panics if called within an asynchronous execution
	/// context.
	///
	/// # Examples
	///
	/// ```
	/// use std::thread;
	/// use tokio::runtime::Runtime;
	/// use tokio::sync::mpsc;
	///
	/// fn main() {
	/// let (tx, mut rx) = mpsc::channel::<u8>(10);
	///
	/// let sync_code = thread::spawn(move || {
	/// assert_eq!(Some(10), rx.blocking_recv());
	/// });
	///
	/// Runtime::new()
	/// .unwrap()
	/// .block_on(async move {
	/// let _ = tx.send(10).await;
	/// });
	/// sync_code.join().unwrap()
	/// }
	/// ```
	#[track_caller]
	#[cfg(feature = "sync")]
	#[cfg_attr(docsrs, doc(alias = "recv_blocking"))]
	pub fn blocking_recv(&mut self) -> Option<T> {
	crate::future::block_on(self.recv())
	}

[debadree25]

Ah thank you very much! will try to open a PR soon!