Struct async_std::sync::Barrier

pub struct Barrier { /* private fields */ }

A counter to synchronize multiple tasks at the same time.

Implementations

impl Barrier

pub const fn new(n: usize) -> Barrier

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

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

Examples

use async_lock::Barrier;

let barrier = Barrier::new(5);

pub async fn wait(&self) -> impl Future<Output = BarrierWaitResult>

Blocks the current task until all tasks reach this point.

Barriers are reusable after all tasks have synchronized, and can be used continuously.

Returns a BarrierWaitResult indicating whether this task is the “leader”, meaning the last task to call this method.

Examples

use async_lock::Barrier;
use futures_lite::future;
use std::sync::Arc;
use std::thread;

let barrier = Arc::new(Barrier::new(5));

for _ in 0..5 {
    let b = barrier.clone();
    thread::spawn(move || {
        future::block_on(async {
            // The same messages will be printed together.
            // There will NOT be interleaving of "before" and "after".
            println!("before wait");
            b.wait().await;
            println!("after wait");
        });
    });
}

Trait Implementations

impl Debug for Barrier

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

Formats the value using the given formatter.