Struct tokio_sync::mpsc::UnboundedReceiver

pub struct UnboundedReceiver<T> { /* fields omitted */ }

Receive values from the associated UnboundedSender.

Instances are created by the unbounded_channel function.

Implementations

impl<T> UnboundedReceiver<T>

pub async fn recv(&mut self) -> Option<T>

Receive the next value for this receiver.

None is returned when all Sender halves have dropped, indicating that no further values can be sent on the channel.

Examples

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    let (mut tx, mut rx) = mpsc::unbounded_channel();

    tokio::spawn(async move {
        tx.try_send("hello").unwrap();
    });

    assert_eq!(Some("hello"), rx.recv().await);
    assert_eq!(None, rx.recv().await);
}

Values are buffered:

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    let (mut tx, mut rx) = mpsc::unbounded_channel();

    tx.try_send("hello").unwrap();
    tx.try_send("world").unwrap();

    assert_eq!(Some("hello"), rx.recv().await);
    assert_eq!(Some("world"), rx.recv().await);
}

pub fn close(&mut self)

Closes the receiving half of a channel, without dropping it.

This prevents any further messages from being sent on the channel while still enabling the receiver to drain messages that are buffered.

Trait Implementations

impl<T> Debug for UnboundedReceiver<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.