CountDownLatch

A synchronization tool that allows one or more threads to wait until a set of operations being performed in other threads completes.

A CountDownLatch is initialized with a count. The await method blocks until the current count reaches zero due to invocations of the count_down() method, after which all waiting threads are released and any subsequent invocations of await return immediately.

A CountDownLatch is thread-safe. Multiple threads can invoke await() to wait for multiple threads to count_down().

Example

``` use countdown_latch::CountDownLatch; use std::sync::Arc; use std::thread; use std::time::Duration;

fn main() { // create a CountDownLatch with count=5 let latch = Arc::new(CountDownLatch::new(5));

// create 5 threads that sleep for a variable amount of time before calling latch.count_down()
for i in 0..5 {
    let tlatch = Arc::clone(&latch);
    thread::spawn(move || {
        thread::sleep(Duration::from_millis(i * 100));
        println!("unlatching {}", i);
        tlatch.count_down();
    });
}

// await completion of the latch
latch.await();

// print done, which will appear in the console after all "unlatching" messages
println!("done");

} ```