Struct CountDownLatch 

pub struct CountDownLatch { /* private fields */ }

A single-use latch that opens when its counter reaches zero.

Any number of threads may call wait which blocks until the internal counter reaches 0. The counter is decremented by calling count_down.

Once opened the latch stays open; subsequent calls to wait return immediately.

Example

use scirs2_core::concurrent::barrier::CountDownLatch;
use std::sync::Arc;

let latch = Arc::new(CountDownLatch::new(3));
let mut handles = Vec::new();
for _ in 0..3 {
    let l = Arc::clone(&latch);
    handles.push(std::thread::spawn(move || l.count_down()));
}
latch.wait().expect("latch wait");
for h in handles { h.join().expect("thread"); }

Implementations

impl CountDownLatch

pub fn new(n: usize) -> Self

Create a latch with an initial count of n.

pub fn count_down(&self)

Decrement the count by 1. When it reaches 0 all waiting threads wake.

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

Block until the count reaches 0.

pub fn wait_timeout(&self, timeout: Duration) -> CoreResult<bool>

Block until the count reaches 0 or timeout elapses.

Returns true if the latch opened within the timeout.

pub fn count(&self) -> usize

Current count (informational, not synchronisation-safe on its own).

pub fn is_open(&self) -> bool

Returns true if the latch has already opened.