Struct Sender

pub struct Sender<T> { /* private fields */ }

🔬This is a nightly-only experimental API. (mpmc_channel)

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>

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

🔬This is a nightly-only experimental API. (mpmc_channel)

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());

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

🔬This is a nightly-only experimental API. (mpmc_channel)

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> Sender<T>

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

🔬This is a nightly-only experimental API. (mpmc_channel)

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();

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

🔬This is a nightly-only experimental API. (mpmc_channel)

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();

pub fn is_empty(&self) -> bool

🔬This is a nightly-only experimental API. (mpmc_channel)

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());

pub fn is_full(&self) -> bool

🔬This is a nightly-only experimental API. (mpmc_channel)

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());

pub fn len(&self) -> usize

🔬This is a nightly-only experimental API. (mpmc_channel)

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);

pub fn capacity(&self) -> Option<usize>

🔬This is a nightly-only experimental API. (mpmc_channel)

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));

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

🔬This is a nightly-only experimental API. (mpmc_channel)

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));

Trait Implementations

impl<T> Clone for Sender<T>

fn clone(&self) -> Sender<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Sender<T>

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

Formats the value using the given formatter.

impl<T> Drop for Sender<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> RefUnwindSafe for Sender<T>

impl<T> Send for Sender<T>

where T: Send,

impl<T> Sync for Sender<T>

where T: Send,

impl<T> UnwindSafe for Sender<T>