Struct crossbeam_channel::Sender

pub struct Sender<T>(_);

The sending side of a channel.

Senders can be cloned and shared among multiple threads.

Examples

use std::thread;
use crossbeam_channel as channel;

let (s1, r) = channel::unbounded();
let s2 = s1.clone();

thread::spawn(move || s1.send(1));
thread::spawn(move || s2.send(2));

let msg1 = r.recv().unwrap();
let msg2 = r.recv().unwrap();

assert_eq!(msg1 + msg2, 3);

Methods

impl<T> Sender<T>

pub fn send(&self, msg: T)

Sends a message into the channel, blocking the current thread if the channel is full.

If called on a zero-capacity channel, this method blocks the current thread until a receive operation appears on the other side of the channel.

Note: s.send(msg) is equivalent to select! { send(s, msg) => {} }.

Examples

use std::thread;
use std::time::Duration;
use crossbeam_channel as channel;

let (s, r) = channel::bounded(0);

thread::spawn(move || s.send(1));

assert_eq!(r.recv(), Some(1));

pub fn is_empty(&self) -> bool

Returns true if the channel is empty.

Note: zero-capacity channels are always empty.

Examples

use crossbeam_channel as channel;

let (s, r) = channel::unbounded();
assert!(s.is_empty());

s.send(0);
assert!(!s.is_empty());

pub fn is_full(&self) -> bool

Returns true if the channel is full.

Note: zero-capacity channels are always full.

Examples

use crossbeam_channel as channel;

let (s, r) = channel::bounded(1);

assert!(!s.is_full());
s.send(0);
assert!(s.is_full());

pub fn len(&self) -> usize

Returns the number of messages in the channel.

Examples

use crossbeam_channel as channel;

let (s, r) = channel::unbounded();
assert_eq!(s.len(), 0);

s.send(1);
s.send(2);
assert_eq!(s.len(), 2);

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

If the channel is bounded, returns its capacity.

Examples

use crossbeam_channel as channel;

let (s, _) = channel::unbounded::<i32>();
assert_eq!(s.capacity(), None);

let (s, _) = channel::bounded::<i32>(5);
assert_eq!(s.capacity(), Some(5));

let (s, _) = channel::bounded::<i32>(0);
assert_eq!(s.capacity(), Some(0));

Trait Implementations

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

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

impl<T> Drop for Sender<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Clone for Sender<T>

fn clone(&self) -> Self

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

Formats the value using the given formatter.

impl<T> Hash for Sender<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl<T> PartialEq for Sender<T>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> Eq for Sender<T>

impl<T> PartialEq<Receiver<T>> for Sender<T>

fn eq(&self, other: &Receiver<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> UnwindSafe for Sender<T>

impl<T> RefUnwindSafe for Sender<T>

impl<T> PartialEq<Sender<T>> for Receiver<T>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.