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

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.

If called on an unbounded channel, this method will never block in order to wait for space to become available. (See std::sync for precise guarantees on blocking.)

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

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

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

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

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

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

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

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

Returns true if the channel is disconnected.

Note that a return value of false does not guarantee the channel will remain connected. The channel may be disconnected immediately after this method returns, so a subsequent Sender::send may still fail with SendError.

Examples

#![feature(mpmc_channel)]

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

let (tx, rx) = channel::<i32>();
assert!(!tx.is_disconnected());
drop(rx);
assert!(tx.is_disconnected());