Struct async_lock::Barrier

source ·
pub struct Barrier { /* private fields */ }
Expand description

A counter to synchronize multiple tasks at the same time.

Implementations§

source§

impl Barrier

source

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

pub fn wait(&self) -> BarrierWait<'_>

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

pub fn wait_blocking(&self) -> BarrierWaitResult

Blocks the current thread 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.

§Blocking

Rather than using asynchronous waiting, like the wait method, this method will block the current thread until the wait is complete.

This method should not be used in an asynchronous context. It is intended to be used in a way that a barrier can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in a deadlock.

§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 || {
        // The same messages will be printed together.
        // There will NOT be interleaving of "before" and "after".
        println!("before wait");
        b.wait_blocking();
        println!("after wait");
    });
}

Trait Implementations§

source§

impl Debug for Barrier

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.