Struct tokio::sync::mpsc::UnboundedReceiver

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

This is supported on crate feature sync only.

Receive values from the associated UnboundedSender.

Instances are created by the unbounded_channel function.

This receiver can be turned into a Stream using UnboundedReceiverStream.

Implementations

impl<T> UnboundedReceiver<T>

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

Receives 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 (tx, mut rx) = mpsc::unbounded_channel();

    tokio::spawn(async move {
        tx.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 (tx, mut rx) = mpsc::unbounded_channel();

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

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

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

Blocking receive to call outside of asynchronous contexts.

Panics

This function panics if called within an asynchronous execution context.

Examples

use std::thread;
use tokio::sync::mpsc;

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

    let sync_code = thread::spawn(move || {
        assert_eq!(Some(10), rx.blocking_recv());
    });

    let _ = tx.send(10);
    sync_code.join().unwrap();
}

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.

pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>>

Polls to receive the next message on this channel.

This method returns:

• Poll::Pending if no messages are available but the channel is not closed.
• Poll::Ready(Some(message)) if a message is available.
• Poll::Ready(None) if the channel has been closed and all messages sent before it was closed have been received.

When the method returns Poll::Pending, the Waker in the provided Context is scheduled to receive a wakeup when a message is sent on any receiver, or when the channel is closed. Note that on multiple calls to poll_recv, only the Waker from the Context passed to the most recent call is scheduled to receive a wakeup.

Trait Implementations

impl<T> Debug for UnboundedReceiver<T>

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

Formats the value using the given formatter.