Struct tokio::sync::watch::Sender

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

Sends values to the associated Receiver.

Instances are created by the channel function.

Implementations

impl<T> Sender<T>

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

Sends a new value via the channel, notifying all receivers.

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

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

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.

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")
}

Trait Implementations

impl<T: Debug> Debug for Sender<T>

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

Formats the value using the given formatter.

impl<T> Drop for Sender<T>

fn drop(&mut self)

Executes the destructor for this type.