pub struct Sender<T> { /* private fields */ }
Expand description
Implementations
sourceimpl<T> Sender<T>
impl<T> Sender<T>
sourcepub fn send(&self, value: T) -> Result<(), SendError<T>>
pub fn send(&self, value: T) -> Result<(), SendError<T>>
Sends a new value via the channel, notifying all receivers.
This method fails if the channel has been closed, which happens when every receiver has been dropped.
sourcepub fn send_replace(&self, value: T) -> T
pub fn send_replace(&self, value: T) -> T
Sends a new value via the channel, notifying all receivers and returning the previous value in the channel.
This can be useful for reusing the buffers inside a watched value. Additionally, this method permits sending values even when there are no receivers.
Examples
use tokio::sync::watch;
let (tx, _rx) = watch::channel(1);
assert_eq!(tx.send_replace(2), 1);
assert_eq!(tx.send_replace(3), 2);
sourcepub fn borrow(&self) -> Ref<'_, T>
pub fn borrow(&self) -> Ref<'_, T>
Returns a reference to the most recently sent value
Outstanding borrows hold a read lock. This means that long lived borrows could cause the send half to block. It is recommended to keep the borrow as short lived as possible.
Examples
use tokio::sync::watch;
let (tx, _) = watch::channel("hello");
assert_eq!(*tx.borrow(), "hello");
sourcepub fn is_closed(&self) -> bool
pub fn is_closed(&self) -> bool
Checks if the channel has been closed. This happens when all receivers have dropped.
Examples
let (tx, rx) = tokio::sync::watch::channel(());
assert!(!tx.is_closed());
drop(rx);
assert!(tx.is_closed());
sourcepub async fn closed(&self)
pub async fn closed(&self)
Completes when all receivers have dropped.
This allows the producer to get notified when interest in the produced values is canceled and immediately stop doing work.
Cancel safety
This method is cancel safe. Once the channel is closed, it stays closed
forever and all future calls to closed
will return immediately.
Examples
use tokio::sync::watch;
#[tokio::main]
async fn main() {
let (tx, rx) = watch::channel("hello");
tokio::spawn(async move {
// use `rx`
drop(rx);
});
// Waits for `rx` to drop
tx.closed().await;
println!("the `rx` handles dropped")
}
sourcepub fn subscribe(&self) -> Receiver<T>
pub fn subscribe(&self) -> Receiver<T>
Creates a new Receiver
connected to this Sender
.
All messages sent before this call to subscribe
are initially marked
as seen by the new Receiver
.
This method can be called even if there are no other receivers. In this case, the channel is reopened.
Examples
The new channel will receive messages sent on this Sender
.
use tokio::sync::watch;
#[tokio::main]
async fn main() {
let (tx, _rx) = watch::channel(0u64);
tx.send(5).unwrap();
let rx = tx.subscribe();
assert_eq!(5, *rx.borrow());
tx.send(10).unwrap();
assert_eq!(10, *rx.borrow());
}
The most recent message is considered seen by the channel, so this test is guaranteed to pass.
use tokio::sync::watch;
use tokio::time::Duration;
#[tokio::main]
async fn main() {
let (tx, _rx) = watch::channel(0u64);
tx.send(5).unwrap();
let mut rx = tx.subscribe();
tokio::spawn(async move {
// by spawning and sleeping, the message is sent after `main`
// hits the call to `changed`.
tokio::time::sleep(Duration::from_millis(10)).await;
tx.send(100).unwrap();
});
rx.changed().await.unwrap();
assert_eq!(100, *rx.borrow());
}
sourcepub fn receiver_count(&self) -> usize
pub fn receiver_count(&self) -> usize
Returns the number of receivers that currently exist.
Examples
use tokio::sync::watch;
#[tokio::main]
async fn main() {
let (tx, rx1) = watch::channel("hello");
assert_eq!(1, tx.receiver_count());
let mut _rx2 = rx1.clone();
assert_eq!(2, tx.receiver_count());
}
Trait Implementations
Auto Trait Implementations
impl<T> !RefUnwindSafe for Sender<T>
impl<T> Send for Sender<T> where
T: Send + Sync,
impl<T> Sync for Sender<T> where
T: Send + Sync,
impl<T> Unpin for Sender<T>
impl<T> !UnwindSafe for Sender<T>
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