1.0.0[−][src]Struct std::sync::mpsc::SyncSender
The sending-half of Rust's synchronous sync_channel
type.
Messages can be sent through this channel with send
or try_send
.
send
will block if there is no space in the internal buffer.
Examples
use std::sync::mpsc::sync_channel; use std::thread; // Create a sync_channel with buffer size 2 let (sync_sender, receiver) = sync_channel(2); let sync_sender2 = sync_sender.clone(); // First thread owns sync_sender thread::spawn(move || { sync_sender.send(1).unwrap(); sync_sender.send(2).unwrap(); }); // Second thread owns sync_sender2 thread::spawn(move || { sync_sender2.send(3).unwrap(); // thread will now block since the buffer is full println!("Thread unblocked!"); }); let mut msg; msg = receiver.recv().unwrap(); println!("message {} received", msg); // "Thread unblocked!" will be printed now msg = receiver.recv().unwrap(); println!("message {} received", msg); msg = receiver.recv().unwrap(); println!("message {} received", msg);Run
Methods
impl<T> SyncSender<T>
[src]
pub fn send(&self, t: T) -> Result<(), SendError<T>>
[src]
Sends a value on this synchronous channel.
This function will block until space in the internal buffer becomes available or a receiver is available to hand off the message to.
Note that a successful send does not guarantee that the receiver will ever see the data if there is a buffer on this channel. Items may be enqueued in the internal buffer for the receiver to receive at a later time. If the buffer size is 0, however, the channel becomes a rendezvous channel and it guarantees that the receiver has indeed received the data if this function returns success.
This function will never panic, but it may return Err
if the
Receiver
has disconnected and is no longer able to receive
information.
Examples
use std::sync::mpsc::sync_channel; use std::thread; // Create a rendezvous sync_channel with buffer size 0 let (sync_sender, receiver) = sync_channel(0); thread::spawn(move || { println!("sending message..."); sync_sender.send(1).unwrap(); // Thread is now blocked until the message is received println!("...message received!"); }); let msg = receiver.recv().unwrap(); assert_eq!(1, msg);Run
pub fn try_send(&self, t: T) -> Result<(), TrySendError<T>>
[src]
Attempts to send a value on this channel without blocking.
This method differs from send
by returning immediately if the
channel's buffer is full or no receiver is waiting to acquire some
data. Compared with send
, this function has two failure cases
instead of one (one for disconnection, one for a full buffer).
See send
for notes about guarantees of whether the
receiver has received the data or not if this function is successful.
Examples
use std::sync::mpsc::sync_channel; use std::thread; // Create a sync_channel with buffer size 1 let (sync_sender, receiver) = sync_channel(1); let sync_sender2 = sync_sender.clone(); // First thread owns sync_sender thread::spawn(move || { sync_sender.send(1).unwrap(); sync_sender.send(2).unwrap(); // Thread blocked }); // Second thread owns sync_sender2 thread::spawn(move || { // This will return an error and send // no message if the buffer is full let _ = sync_sender2.try_send(3); }); let mut msg; msg = receiver.recv().unwrap(); println!("message {} received", msg); msg = receiver.recv().unwrap(); println!("message {} received", msg); // Third message may have never been sent match receiver.try_recv() { Ok(msg) => println!("message {} received", msg), Err(_) => println!("the third message was never sent"), }Run
Trait Implementations
impl<T: Send> Send for SyncSender<T>
[src]
impl<T> Debug for SyncSender<T>
1.8.0[src]
impl<T> Drop for SyncSender<T>
[src]
impl<T> Clone for SyncSender<T>
[src]
fn clone(&self) -> SyncSender<T>
[src]
fn clone_from(&mut self, source: &Self)
[src]
Performs copy-assignment from source
. Read more
Auto Trait Implementations
impl<T> Sync for SyncSender<T> where
T: Send,
T: Send,
Blanket Implementations
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.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
ⓘImportant traits for &'_ mut Ffn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,