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.

This method fails if the channel has been closed, which happens when every receiver has been dropped.

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

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.

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

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

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

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.