wait until all the threads had stoped running

[ghost]

runtime.spawn(async move {
    let system_box = SystemBox {
        system: continious_system,
    };
    loop {
        if let Some(canvas) = canvas_rx.recv().await {
            for system in &system_box.system {
                let canvas = canvas.clone();
                tokio::spawn((system)(canvas));
            };
            // wait until all tokio::spawn((system)(canvas)); are completed before exiting loop
        }
    }
});

[Darksonn]

let mut handles = Vec::new();

for system in &system_box.system {
    let canvas = canvas.clone();
    let handle = tokio::spawn((system)(canvas));
    handles.push(handle);
}

for handle in handles {
    handle.await.unwrap();
}

[ghost]

Thanks,
I checked the code it works exactly as i wanted but

runtime.spawn(async move {
    let mut systems = Vec::new();
    for system in continious_system {
        systems.push(Arc::new(system))
    }
    loop {
        if let Some(canvas) = canvas_rx.recv().await {
            let mut handles = Vec::new();

            for system in &systems {
                let canvas = canvas.clone();
                let handle = tokio::spawn((system)(canvas));
                handles.push(handle);
            }

            for handle in handles {
                handle.await.unwrap();
            }
            
        }
        println!("done")
    }
});

while waiting for reply i hunted the tokio crate for solution and i found tokio also have LocalSet that use notify to get that same result since LocalSet was not working with my borrow method so i used this code. Could you tell which would extract more performance

runtime.spawn(async move {
    let mut systems = Vec::new();
    for system in continious_system {
        systems.push(Arc::new(system))
    }
    loop {
        if let Some(canvas) = canvas_rx.recv().await {
            let mut process_counter: Vec<Arc<sync::Notify>> =
                Vec::with_capacity(systems.len());
            for system in &systems {
                let canvas = canvas.clone();
                let notify = Arc::new(tokio::sync::Notify::new());
                process_counter.push(notify.clone());
                let system = system.clone();
                tokio::spawn(async move {
                    (system)(canvas).await;
                    notify.notify_one();
                });
            }
            for notify in process_counter {
                notify.notified().await;
            }
        }
        println!("done")
    }
});

[Darksonn]

Using a vector of arcs of Notify objects would be more expensive than the JoinHandle vector.