Struct WaitGroup 

pub struct WaitGroup { /* private fields */ }

WaitGroup is a synchronization primitive that allows to wait until all tasks are completed.

The difference between WaitGroup and LocalWaitGroup

The WaitGroup works with shared tasks and can be shared between threads.

Read Executor for more details.

Example

use std::time::Duration;
use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
use orengine::sleep;
use orengine::sync::{shared_scope, AsyncWaitGroup, WaitGroup};

let wait_group = WaitGroup::new();
let number_executed_tasks = AtomicUsize::new(0);

shared_scope(|scope| async {
    for i in 0..10 {
        wait_group.inc();
        scope.spawn(async {
            sleep(Duration::from_millis(i)).await;
            number_executed_tasks.fetch_add(1, SeqCst);
            wait_group.done();
        });
    }

    wait_group.wait().await; // wait until all tasks are completed
    assert_eq!(number_executed_tasks.load(SeqCst), 10);
}).await;

Implementations

impl WaitGroup

pub fn new() -> Self

Creates a new WaitGroup.

Trait Implementations

impl AsyncWaitGroup for WaitGroup

fn add(&self, count: usize)

Adds count to the LocalWaitGroup counter.

fn count(&self) -> usize

Returns the LocalWaitGroup counter.

fn done(&self) -> usize

Decreases the LocalWaitGroup counter by 1 and wakes up all tasks that are waiting if the counter reaches 0.

fn wait(&self) -> impl Future<Output = ()>

Waits until the LocalWaitGroup counter reaches 0.

fn inc(&self)

Adds 1 to the LocalWaitGroup counter.

impl Default for WaitGroup

fn default() -> Self

Returns the “default value” for a type.

impl RefUnwindSafe for WaitGroup

impl Send for WaitGroup

impl Sync for WaitGroup

impl UnwindSafe for WaitGroup