Struct `WaitGroup`

pub struct WaitGroup { /* private fields */ }

Enables threads to synchronize the beginning or end of some computation.

Wait groups vs barriers

WaitGroup is very similar to Barrier, but there are a few differences:

Barrier needs to know the number of threads at construction, while WaitGroup is cloned to register more threads.
A Barrier can be reused even after all threads have synchronized, while a WaitGroup synchronizes threads only once.
All threads wait for others to reach the Barrier. With WaitGroup, each thread can choose to either wait for other threads or to continue without blocking.

Examples

use crossbeam_utils::sync::WaitGroup;
use std::thread;

// Create a new wait group.
let wg = WaitGroup::new();

for _ in 0..4 {
    // Create another reference to the wait group.
    let wg = wg.clone();

    thread::spawn(move || {
        // Do some work.

        // Drop the reference to the wait group.
        drop(wg);
    });
}

// Block until all threads have finished their work.
wg.wait();
# std::thread::sleep(std::time::Duration::from_millis(500)); // wait for background threads closed: https://github.com/rust-lang/miri/issues/1371

Implementations

`impl WaitGroup`

fn new() -> Self

Creates a new wait group and returns the single reference to it.

Examples

use crossbeam_utils::sync::WaitGroup;

let wg = WaitGroup::new();

fn wait(self)

Drops this reference and waits until all other references are dropped.

Examples

use crossbeam_utils::sync::WaitGroup;
use std::thread;

let wg = WaitGroup::new();

thread::spawn({
    let wg = wg.clone();
    move || {
        // Block until both threads have reached `wait()`.
        wg.wait();
    }
});

// Block until both threads have reached `wait()`.
wg.wait();
# std::thread::sleep(std::time::Duration::from_millis(500)); // wait for background threads closed: https://github.com/rust-lang/miri/issues/1371