Struct CyclicBarrier

pub struct CyclicBarrier { /* private fields */ }

Cyclic Barrier implementation.

It basically provides 2 methods:

let barrier = CyclicBarrier::new(count); // initialize a cyclic barrier with 3 parties barrier.wait(); // Wait until all parties are wait. Returnes Ok(()) for the last one entered the state

Most of the time, you should use Arc(barrier).

You can clone the Arc container of barrier as many times as you want. // You can reuse the barrier if the config does not need to be changed.

drop(barrier); // discard the barrier after you are done with it.

Usage: Example:

use std::sync::Arc;
use std::time::Duration;
use std::thread;
use classic_sync::cyclic_barrier::CyclicBarrier;
let barrier = CyclicBarrier::new(3);
let arc_barrier = Arc::new(barrier);
for i in 0..3 {
    let barrier_copy = Arc::clone(&arc_barrier);
    let tid = i;
    thread::spawn(move || {
        // if you care who's wait call triggered everyone to go, you can check the
        // firing object returned. If it is Some(_), it triggered the barrier
        let firing = barrier_copy.wait();
 
        if firing.is_some() {
            println!("Thread {tid} is the one triggered it!");
        }
        println!("Now we are starting almost at the same time!!");
    });
}
 
 

Implementations

impl CyclicBarrier

Implementation of CyclicBarrier

pub fn new(count: u32) -> CyclicBarrier

Create a new CyclicBarrier with count of count. It is backed by a C pthread_barrier_t object. count must be greater than 0. If not behavior is not determined.

pub fn wait(&self) -> Option<()>

Wait for other parties If the caller is the last one enters the barrier and triggered the barrier release Then result is Some(()). Otherwise, result is None.

Trait Implementations

impl Drop for CyclicBarrier

Close internal pthread_barrier_t object on Drop

fn drop(&mut self)

Executes the destructor for this type.