pub struct Receiver<T> { /* private fields */ }
Expand description

Receives values from the associated Sender.

Instances are created by the channel function.

This receiver can be turned into a Stream using ReceiverStream.

Implementations

Receives the next value for this receiver.

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 sleep until a message is sent or the channel is closed. Note that if close is called, but there are still outstanding Permits from before it was closed, the channel is not considered closed by recv until the permits are released.

Cancel safety

This method is cancel safe. If recv is used as the event in a tokio::select! statement and some other branch completes first, it is guaranteed that no messages were received on this channel.

Examples
use tokio::sync::mpsc;

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

    tokio::spawn(async move {
        tx.send("hello").await.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::channel(100);

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

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

Tries to receive the next value for this receiver.

This method returns the Empty error if the channel is currently empty, but there are still outstanding senders or permits.

This method returns the Disconnected error if the channel is currently empty, and there are no outstanding senders or permits.

Unlike the poll_recv method, this method will never return an Empty error spuriously.

Examples
use tokio::sync::mpsc;
use tokio::sync::mpsc::error::TryRecvError;

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

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

    assert_eq!(Ok("hello"), rx.try_recv());
    assert_eq!(Err(TryRecvError::Empty), rx.try_recv());

    tx.send("hello").await.unwrap();
    // Drop the last sender, closing the channel.
    drop(tx);

    assert_eq!(Ok("hello"), rx.try_recv());
    assert_eq!(Err(TryRecvError::Disconnected), rx.try_recv());
}

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.

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()
}

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. Any outstanding Permit values will still be able to send messages.

To guarantee that no messages are dropped, after calling close(), recv() must be called until None is returned. If there are outstanding Permit or OwnedPermit values, the recv method will not return None until those are released.

Examples
use tokio::sync::mpsc;

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

    tokio::spawn(async move {
        let mut i = 0;
        while let Ok(permit) = tx.reserve().await {
            permit.send(i);
            i += 1;
        }
    });

    rx.close();

    while let Some(msg) = rx.recv().await {
        println!("got {}", msg);
    }

    // Channel closed and no messages are lost.
}

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, or if a spurious failure happens.
  • 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.

If this method returns Poll::Pending due to a spurious failure, then the Waker will be notified when the situation causing the spurious failure has been resolved. Note that receiving such a wakeup does not guarantee that the next call will succeed — it could fail with another spurious failure.

Trait Implementations

Formats the value using the given formatter. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.