Sender in std::sync::mpmc - Rust
Description: The sending-half of Rust’s synchronous `channel` type.

## Sender

# Struct Sender

Source

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

🔬This is a nightly-only experimental API. (`mpmc_channel` #126840)
Expand description

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§

Source§

### impl<T> Sender<T>

Source

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

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

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

Source

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

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

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

Source§

### impl<T> Sender<T>

Source

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

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

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

Source

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

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

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

Source

#### pub fn is_empty(&self) -> bool

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

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

Source

#### pub fn is_full(&self) -> bool

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

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

Source

#### pub fn len(&self) -> usize

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

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

Source

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

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

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

Source

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

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

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§

Source§

### impl<T> Clone for Sender<T>

Source§

#### fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from `source`. Read more
Source§

### impl<T> Debug for Sender<T>

Source§

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

Formats the value using the given formatter. Read more
Source§

### impl<T> Drop for Sender<T>

Source§

#### fn drop(&mut self)

Executes the destructor for this type. Read more
Source§

### impl<T> RefUnwindSafe for Sender<T>

Source§

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

Source§

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

Source§

### impl<T> UnwindSafe for Sender<T>

## Auto Trait Implementations§

§

### impl<T> Freeze for Sender<T>

§

### impl<T> Unpin for Sender<T>

## Blanket Implementations§

Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> CloneToUninit for T
where T: Clone,

Source§

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

🔬This is a nightly-only experimental API. (`clone_to_uninit` #126799)
Performs copy-assignment from `self` to `dest`. Read more
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

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

Source§

### impl<T> ToOwned for T
where T: Clone,

Source§

#### type Owned = T

The resulting type after obtaining ownership.
Source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.