Struct Sender

struct Sender<T> { ... }

The sending-half of Rust's synchronous channel type.

Messages can be sent through this channel with send.

Note: all senders (the original and its clones) need to be dropped for the receiver to stop blocking to receive messages with Receiver::recv.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc::channel;
use std::thread;

let (sender, receiver) = channel();
let sender2 = sender.clone();

// First thread owns sender
thread::spawn(move || {
    sender.send(1).unwrap();
});

// Second thread owns sender2
thread::spawn(move || {
    sender2.send(2).unwrap();
});

let msg = receiver.recv().unwrap();
let msg2 = receiver.recv().unwrap();

assert_eq!(3, msg + msg2);

Implementations

impl<T> Sender<T>

fn send_timeout(self: &Self, msg: T, timeout: Duration) -> Result<(), SendTimeoutError<T>>

Waits for a message to be sent into the channel, but only for a limited time.

If the channel is full and not disconnected, this call will block until the send operation can proceed or the operation times out. If the channel becomes disconnected, this call will wake up and return an error. The returned error contains the original message.

If called on a zero-capacity channel, this method will wait for a receive operation to appear on the other side of the channel.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc::channel;
use std::time::Duration;

let (tx, rx) = channel();

tx.send_timeout(1, Duration::from_millis(400)).unwrap();

fn send_deadline(self: &Self, msg: T, deadline: Instant) -> Result<(), SendTimeoutError<T>>

Waits for a message to be sent into the channel, but only until a given deadline.

If the channel is full and not disconnected, this call will block until the send operation can proceed or the operation times out. If the channel becomes disconnected, this call will wake up and return an error. The returned error contains the original message.

If called on a zero-capacity channel, this method will wait for a receive operation to appear on the other side of the channel.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc::channel;
use std::time::{Duration, Instant};

let (tx, rx) = channel();

let t = Instant::now() + Duration::from_millis(400);
tx.send_deadline(1, t).unwrap();

fn is_empty(self: &Self) -> bool

Returns true if the channel is empty.

Note: Zero-capacity channels are always empty.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc;
use std::thread;

let (send, _recv) = mpmc::channel();

let tx1 = send.clone();
let tx2 = send.clone();

assert!(tx1.is_empty());

let handle = thread::spawn(move || {
    tx2.send(1u8).unwrap();
});

handle.join().unwrap();

assert!(!tx1.is_empty());

fn is_full(self: &Self) -> bool

Returns true if the channel is full.

Note: Zero-capacity channels are always full.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc;
use std::thread;

let (send, _recv) = mpmc::sync_channel(1);

let (tx1, tx2) = (send.clone(), send.clone());
assert!(!tx1.is_full());

let handle = thread::spawn(move || {
    tx2.send(1u8).unwrap();
});

handle.join().unwrap();

assert!(tx1.is_full());

fn len(self: &Self) -> usize

Returns the number of messages in the channel.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc;
use std::thread;

let (send, _recv) = mpmc::channel();
let (tx1, tx2) = (send.clone(), send.clone());

assert_eq!(tx1.len(), 0);

let handle = thread::spawn(move || {
    tx2.send(1u8).unwrap();
});

handle.join().unwrap();

assert_eq!(tx1.len(), 1);

fn capacity(self: &Self) -> Option<usize>

If the channel is bounded, returns its capacity.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc;
use std::thread;

let (send, _recv) = mpmc::sync_channel(3);
let (tx1, tx2) = (send.clone(), send.clone());

assert_eq!(tx1.capacity(), Some(3));

let handle = thread::spawn(move || {
    tx2.send(1u8).unwrap();
});

handle.join().unwrap();

assert_eq!(tx1.capacity(), Some(3));

fn same_channel(self: &Self, other: &Sender<T>) -> bool

Returns true if senders belong to the same channel.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc;

let (tx1, _) = mpmc::channel::<i32>();
let (tx2, _) = mpmc::channel::<i32>();

assert!(tx1.same_channel(&tx1));
assert!(!tx1.same_channel(&tx2));

impl<T> Sender<T>

fn try_send(self: &Self, msg: T) -> Result<(), TrySendError<T>>

Attempts to send a message into the channel without blocking.

This method will either send a message into the channel immediately or return an error if the channel is full or disconnected. The returned error contains the original message.

If called on a zero-capacity channel, this method will send the message only if there happens to be a receive operation on the other side of the channel at the same time.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc::{channel, Receiver, Sender};

let (sender, _receiver): (Sender<i32>, Receiver<i32>) = channel();

assert!(sender.try_send(1).is_ok());

fn send(self: &Self, msg: T) -> Result<(), SendError<T>>

Attempts to send a value on this channel, returning it back if it could not be sent.

A successful send occurs when it is determined that the other end of the channel has not hung up already. An unsuccessful send would be one where the corresponding receiver has already been deallocated. Note that a return value of Err means that the data will never be received, but a return value of Ok does not mean that the data will be received. It is possible for the corresponding receiver to hang up immediately after this function returns Ok. However, if the channel is zero-capacity, it acts as a rendezvous channel and a return value of Ok means that the data has been received.

If the channel is full and not disconnected, this call will block until the send operation can proceed. If the channel becomes disconnected, this call will wake up and return an error. The returned error contains the original message.

If called on a zero-capacity channel, this method will wait for a receive operation to appear on the other side of the channel.

Examples

#![feature(mpmc_channel)]

use std::sync::mpmc::channel;

let (tx, rx) = channel();

// This send is always successful
tx.send(1).unwrap();

// This send will fail because the receiver is gone
drop(rx);
assert!(tx.send(1).is_err());

impl<T> Any for Sender<T>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Sender<T>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Sender<T>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> Clone for Sender<T>

fn clone(self: &Self) -> Self

impl<T> CloneToUninit for Sender<T>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> Debug for Sender<T>

fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result

impl<T> Drop for Sender<T>

fn drop(self: &mut Self)

impl<T> Freeze for Sender<T>

impl<T> From for Sender<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> RefUnwindSafe for Sender<T>

impl<T> ToOwned for Sender<T>

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

impl<T> Unpin for Sender<T>

impl<T> UnwindSafe for Sender<T>

impl<T, U> Into for Sender<T>

fn into(self: Self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom for Sender<T>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Sender<T>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T: Send> Send for Sender<T>

impl<T: Send> Sync for Sender<T>