Struct tokio::sync::Barrier

pub struct Barrier { /* private fields */ }

Available on crate feature sync only.

A barrier enables multiple tasks to synchronize the beginning of some computation.

use tokio::sync::Barrier;
use std::sync::Arc;

let mut handles = Vec::with_capacity(10);
let barrier = Arc::new(Barrier::new(10));
for _ in 0..10 {
    let c = barrier.clone();
    // The same messages will be printed together.
    // You will NOT see any interleaving.
    handles.push(tokio::spawn(async move {
        println!("before wait");
        let wait_result = c.wait().await;
        println!("after wait");
        wait_result
    }));
}

// Will not resolve until all "after wait" messages have been printed
let mut num_leaders = 0;
for handle in handles {
    let wait_result = handle.await.unwrap();
    if wait_result.is_leader() {
        num_leaders += 1;
    }
}

// Exactly one barrier will resolve as the "leader"
assert_eq!(num_leaders, 1);

Implementations

impl Barrier

pub fn new(n: usize) -> Barrier

Creates a new barrier that can block a given number of tasks.

A barrier will block n-1 tasks which call Barrier::wait and then wake up all tasks at once when the nth task calls wait.

pub async fn wait(&self) -> BarrierWaitResult

Does not resolve until all tasks have rendezvoused here.

Barriers are re-usable after all tasks have rendezvoused once, and can be used continuously.

A single (arbitrary) future will receive a BarrierWaitResult that returns true from BarrierWaitResult::is_leader when returning from this function, and all other tasks will receive a result that will return false from is_leader.

Cancel safety

This method is not cancel safe.

Trait Implementations

impl Debug for Barrier

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 56 bytes