Struct Barrier

pub struct Barrier { pub(in ::sync::barrier) lock: Mutex<BarrierState>, pub(in ::sync::barrier) cvar: Condvar, pub(in ::sync::barrier) num_threads: usize }

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

Examples

use std::sync::Barrier;
use std::thread;

let n = 10;
let barrier = Barrier::new(n);
thread::scope(|s| {
    for _ in 0..n {
        // The same messages will be printed together.
        // You will NOT see any interleaving.
        s.spawn(|| {
            println!("before wait");
            barrier.wait();
            println!("after wait");
        });
    }
});

Fields

lock: Mutex<BarrierState>
cvar: Condvar
num_threads: usize

Implementations

impl Barrier

const fn new(n: usize) -> Barrier

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

A barrier will block all threads which call wait() until the nth thread calls wait(), and then wake up all threads at once.

Examples

use std::sync::Barrier;

let barrier = Barrier::new(10);

fn wait(&self) -> BarrierWaitResult

Blocks the current thread until all threads have rendezvoused here.

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

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

Examples

use std::sync::Barrier;
use std::thread;

let n = 10;
let barrier = Barrier::new(n);
thread::scope(|s| {
    for _ in 0..n {
        // The same messages will be printed together.
        // You will NOT see any interleaving.
        s.spawn(|| {
            println!("before wait");
            barrier.wait();
            println!("after wait");
        });
    }
});

Trait Implementations

impl Debug for Barrier

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

impl RefUnwindSafe for Barrier

Auto Trait Implementations

impl !Freeze for Barrier

impl Send for Barrier

impl Sync for Barrier

impl Unpin for Barrier

impl UnsafeUnpin for Barrier

impl UnwindSafe for Barrier

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> From<T> for Barrier

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for Barrier where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for Barrier

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

fn into(self) -> U

Calls U::from(self).

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

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

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

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

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