Struct Barrier
pub struct Barrier { /* private fields */ }
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
Auto Trait Implementations
impl !Freeze for Barrier
impl !RefUnwindSafe for Barrier
impl !UnwindSafe for Barrier
impl Send for Barrier
impl Sync for Barrier
impl Unpin for Barrier
impl UnsafeUnpin for Barrier
Blanket Implementations
impl<T> BorrowMut<T> for Twhere T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
impl<T> Instrument for T
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
impl<T> WithSubscriber for T
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
MIT License
Copyright © Tokio Contributors
https://docs.rs/tokio/1.53.1/tokio/sync/struct.Barrier.html