[−][src]Struct tokio::sync::mpsc::Receiver
sync
only.Receive values from the associated Sender
.
Instances are created by the channel
function.
Implementations
impl<T> Receiver<T>
[src]
pub async fn recv<'_>(&'_ mut self) -> Option<T>
[src]
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::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); }
pub fn blocking_recv(&mut self) -> Option<T>
[src]
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::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() }
pub fn close(&mut self)
[src]
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.
In order to guarantee no messages are dropped, after calling close()
,
recv()
must be called until None
is returned.
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. }
pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>>
[src]
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
Auto Trait Implementations
impl<T> !RefUnwindSafe for Receiver<T>
[src]
impl<T> Send for Receiver<T> where
T: Send,
[src]
T: Send,
impl<T> Sync for Receiver<T> where
T: Send,
[src]
T: Send,
impl<T> !UnwindSafe for Receiver<T>
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,