pub struct Sender<T> { /* private fields */ }
Expand description
Sending-half of the broadcast
channel.
May be used from many threads. Messages can be sent with
send
.
Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, mut rx1) = broadcast::channel(16);
let mut rx2 = tx.subscribe();
tokio::spawn(async move {
assert_eq!(rx1.recv().await.unwrap(), 10);
assert_eq!(rx1.recv().await.unwrap(), 20);
});
tokio::spawn(async move {
assert_eq!(rx2.recv().await.unwrap(), 10);
assert_eq!(rx2.recv().await.unwrap(), 20);
});
tx.send(10).unwrap();
tx.send(20).unwrap();
}
Implementations
sourceimpl<T> Sender<T>
impl<T> Sender<T>
sourcepub fn send(&self, value: T) -> Result<usize, SendError<T>>
pub fn send(&self, value: T) -> Result<usize, SendError<T>>
Attempts to send a value to all active Receiver
handles, returning
it back if it could not be sent.
A successful send occurs when there is at least one active Receiver
handle. An unsuccessful send would be one where all associated
Receiver
handles have already been dropped.
Return
On success, the number of subscribed Receiver
handles is returned.
This does not mean that this number of receivers will see the message as
a receiver may drop before receiving the message.
Note
A return value of Ok
does not mean that the sent value will be
observed by all or any of the active Receiver
handles. Receiver
handles may be dropped before receiving the sent message.
A return value of Err
does not mean that future calls to send
will fail. New Receiver
handles may be created by calling
subscribe
.
Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, mut rx1) = broadcast::channel(16);
let mut rx2 = tx.subscribe();
tokio::spawn(async move {
assert_eq!(rx1.recv().await.unwrap(), 10);
assert_eq!(rx1.recv().await.unwrap(), 20);
});
tokio::spawn(async move {
assert_eq!(rx2.recv().await.unwrap(), 10);
assert_eq!(rx2.recv().await.unwrap(), 20);
});
tx.send(10).unwrap();
tx.send(20).unwrap();
}
sourcepub fn subscribe(&self) -> Receiver<T>
pub fn subscribe(&self) -> Receiver<T>
Creates a new Receiver
handle that will receive values sent after
this call to subscribe
.
Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, _rx) = broadcast::channel(16);
// Will not be seen
tx.send(10).unwrap();
let mut rx = tx.subscribe();
tx.send(20).unwrap();
let value = rx.recv().await.unwrap();
assert_eq!(20, value);
}
sourcepub fn receiver_count(&self) -> usize
pub fn receiver_count(&self) -> usize
Returns the number of active receivers
An active receiver is a Receiver
handle returned from channel
or
subscribe
. These are the handles that will receive values sent on
this Sender
.
Note
It is not guaranteed that a sent message will reach this number of
receivers. Active receivers may never call recv
again before
dropping.
Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, _rx1) = broadcast::channel(16);
assert_eq!(1, tx.receiver_count());
let mut _rx2 = tx.subscribe();
assert_eq!(2, tx.receiver_count());
tx.send(10).unwrap();
}
Trait Implementations
impl<T: Send> Send for Sender<T>
impl<T: Send> Sync for Sender<T>
Auto Trait Implementations
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more