Struct `WaitGroup`

struct WaitGroup { ... }

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: 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

`impl Clone for WaitGroup`

fn clone(self: &Self) -> WaitGroup

`impl Debug for WaitGroup`

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

`impl Default for WaitGroup`

fn default() -> Self

`impl Drop for WaitGroup`

fn drop(self: &mut Self)

`impl Freeze for WaitGroup`

`impl RefUnwindSafe for WaitGroup`

`impl Send for WaitGroup`

`impl Sync for WaitGroup`

`impl Unpin for WaitGroup`

`impl UnwindSafe for WaitGroup`

`impl<T> Any for WaitGroup`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for WaitGroup`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for WaitGroup`

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

`impl<T> CloneToUninit for WaitGroup`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for WaitGroup`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for WaitGroup`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for WaitGroup`

fn into(self: 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 for WaitGroup`

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

`impl<T, U> TryInto for WaitGroup`

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