Struct otter_api_tests::mpsc::Receiver 1.0.0[−][src]
pub struct Receiver<T> { /* fields omitted */ }
Expand description
The receiving half of Rust’s channel
(or sync_channel
) type.
This half can only be owned by one thread.
Messages sent to the channel can be retrieved using recv
.
Examples
use std::sync::mpsc::channel; use std::thread; use std::time::Duration; let (send, recv) = channel(); thread::spawn(move || { send.send("Hello world!").unwrap(); thread::sleep(Duration::from_secs(2)); // block for two seconds send.send("Delayed for 2 seconds").unwrap(); }); println!("{}", recv.recv().unwrap()); // Received immediately println!("Waiting..."); println!("{}", recv.recv().unwrap()); // Received after 2 seconds
Implementations
Attempts to return a pending value on this receiver without blocking.
This method will never block the caller in order to wait for data to become available. Instead, this will always return immediately with a possible option of pending data on the channel.
This is useful for a flavor of “optimistic check” before deciding to block on a receiver.
Compared with recv
, this function has two failure cases instead of one
(one for disconnection, one for an empty buffer).
Examples
use std::sync::mpsc::{Receiver, channel}; let (_, receiver): (_, Receiver<i32>) = channel(); assert!(receiver.try_recv().is_err());
Attempts to wait for a value on this receiver, returning an error if the corresponding channel has hung up.
This function will always block the current thread if there is no data
available and it’s possible for more data to be sent. Once a message is
sent to the corresponding Sender
(or SyncSender
), then this
receiver will wake up and return that message.
If the corresponding Sender
has disconnected, or it disconnects while
this call is blocking, this call will wake up and return Err
to
indicate that no more messages can ever be received on this channel.
However, since channels are buffered, messages sent before the disconnect
will still be properly received.
Examples
use std::sync::mpsc; use std::thread; let (send, recv) = mpsc::channel(); let handle = thread::spawn(move || { send.send(1u8).unwrap(); }); handle.join().unwrap(); assert_eq!(Ok(1), recv.recv());
Buffering behavior:
use std::sync::mpsc; use std::thread; use std::sync::mpsc::RecvError; let (send, recv) = mpsc::channel(); let handle = thread::spawn(move || { send.send(1u8).unwrap(); send.send(2).unwrap(); send.send(3).unwrap(); drop(send); }); // wait for the thread to join so we ensure the sender is dropped handle.join().unwrap(); assert_eq!(Ok(1), recv.recv()); assert_eq!(Ok(2), recv.recv()); assert_eq!(Ok(3), recv.recv()); assert_eq!(Err(RecvError), recv.recv());
Attempts to wait for a value on this receiver, returning an error if the
corresponding channel has hung up, or if it waits more than timeout
.
This function will always block the current thread if there is no data
available and it’s possible for more data to be sent. Once a message is
sent to the corresponding Sender
(or SyncSender
), then this
receiver will wake up and return that message.
If the corresponding Sender
has disconnected, or it disconnects while
this call is blocking, this call will wake up and return Err
to
indicate that no more messages can ever be received on this channel.
However, since channels are buffered, messages sent before the disconnect
will still be properly received.
Known Issues
There is currently a known issue (see #39364
) that causes recv_timeout
to panic unexpectedly with the following example:
use std::sync::mpsc::channel; use std::thread; use std::time::Duration; let (tx, rx) = channel::<String>(); thread::spawn(move || { let d = Duration::from_millis(10); loop { println!("recv"); let _r = rx.recv_timeout(d); } }); thread::sleep(Duration::from_millis(100)); let _c1 = tx.clone(); thread::sleep(Duration::from_secs(1));
Examples
Successfully receiving value before encountering timeout:
use std::thread; use std::time::Duration; use std::sync::mpsc; let (send, recv) = mpsc::channel(); thread::spawn(move || { send.send('a').unwrap(); }); assert_eq!( recv.recv_timeout(Duration::from_millis(400)), Ok('a') );
Receiving an error upon reaching timeout:
use std::thread; use std::time::Duration; use std::sync::mpsc; let (send, recv) = mpsc::channel(); thread::spawn(move || { thread::sleep(Duration::from_millis(800)); send.send('a').unwrap(); }); assert_eq!( recv.recv_timeout(Duration::from_millis(400)), Err(mpsc::RecvTimeoutError::Timeout) );
🔬 This is a nightly-only experimental API. (deadline_api
)
deadline_api
)Attempts to wait for a value on this receiver, returning an error if the
corresponding channel has hung up, or if deadline
is reached.
This function will always block the current thread if there is no data
available and it’s possible for more data to be sent. Once a message is
sent to the corresponding Sender
(or SyncSender
), then this
receiver will wake up and return that message.
If the corresponding Sender
has disconnected, or it disconnects while
this call is blocking, this call will wake up and return Err
to
indicate that no more messages can ever be received on this channel.
However, since channels are buffered, messages sent before the disconnect
will still be properly received.
Examples
Successfully receiving value before reaching deadline:
#![feature(deadline_api)] use std::thread; use std::time::{Duration, Instant}; use std::sync::mpsc; let (send, recv) = mpsc::channel(); thread::spawn(move || { send.send('a').unwrap(); }); assert_eq!( recv.recv_deadline(Instant::now() + Duration::from_millis(400)), Ok('a') );
Receiving an error upon reaching deadline:
#![feature(deadline_api)] use std::thread; use std::time::{Duration, Instant}; use std::sync::mpsc; let (send, recv) = mpsc::channel(); thread::spawn(move || { thread::sleep(Duration::from_millis(800)); send.send('a').unwrap(); }); assert_eq!( recv.recv_deadline(Instant::now() + Duration::from_millis(400)), Err(mpsc::RecvTimeoutError::Timeout) );
Returns an iterator that will block waiting for messages, but never
panic!
. It will return None
when the channel has hung up.
Examples
use std::sync::mpsc::channel; use std::thread; let (send, recv) = channel(); thread::spawn(move || { send.send(1).unwrap(); send.send(2).unwrap(); send.send(3).unwrap(); }); let mut iter = recv.iter(); assert_eq!(iter.next(), Some(1)); assert_eq!(iter.next(), Some(2)); assert_eq!(iter.next(), Some(3)); assert_eq!(iter.next(), None);
Returns an iterator that will attempt to yield all pending values.
It will return None
if there are no more pending values or if the
channel has hung up. The iterator will never panic!
or block the
user by waiting for values.
Examples
use std::sync::mpsc::channel; use std::thread; use std::time::Duration; let (sender, receiver) = channel(); // nothing is in the buffer yet assert!(receiver.try_iter().next().is_none()); thread::spawn(move || { thread::sleep(Duration::from_secs(1)); sender.send(1).unwrap(); sender.send(2).unwrap(); sender.send(3).unwrap(); }); // nothing is in the buffer yet assert!(receiver.try_iter().next().is_none()); // block for two seconds thread::sleep(Duration::from_secs(2)); let mut iter = receiver.try_iter(); assert_eq!(iter.next(), Some(1)); assert_eq!(iter.next(), Some(2)); assert_eq!(iter.next(), Some(3)); assert_eq!(iter.next(), None);
Trait Implementations
Auto Trait Implementations
impl<T> !RefUnwindSafe for Receiver<T>
impl<T> !UnwindSafe for Receiver<T>
Blanket Implementations
Mutably borrows from an owned value. Read more
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<A> DynCastExt for A
impl<A> DynCastExt for A
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
Use this to cast from one trait object type to another. Read more
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
Use this to upcast a trait to one of its supertraits. Read more
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]pub fn vzip(self) -> V