pub struct UnboundedReceiver<T> { /* private fields */ }
Expand description
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
sourceimpl<T> UnboundedReceiver<T>
impl<T> UnboundedReceiver<T>
sourcepub async fn recv(&mut self) -> Option<T>
pub async fn recv(&mut self) -> Option<T>
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.
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::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);
}
sourcepub fn try_recv(&mut self) -> Result<T, TryRecvError>
pub fn try_recv(&mut self) -> Result<T, TryRecvError>
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::unbounded_channel();
tx.send("hello").unwrap();
assert_eq!(Ok("hello"), rx.try_recv());
assert_eq!(Err(TryRecvError::Empty), rx.try_recv());
tx.send("hello").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());
}
sourcepub fn blocking_recv(&mut self) -> Option<T>
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();
}
sourcepub fn close(&mut self)
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.
To guarantee that no messages are dropped, after calling close()
,
recv()
must be called until None
is returned.
sourcepub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>>
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, 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
Auto Trait Implementations
impl<T> !RefUnwindSafe for UnboundedReceiver<T>
impl<T> Send for UnboundedReceiver<T> where
T: Send,
impl<T> Sync for UnboundedReceiver<T> where
T: Send,
impl<T> Unpin for UnboundedReceiver<T>
impl<T> !UnwindSafe for UnboundedReceiver<T>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more