curfew 0.0.5

A deadline-aware fork-join model where multiple tasks run in parallel, but only those that finish before a specified absolute clock time are joined and their results collected.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

use curfew::{DeadlineJoiner, TaskOutcome};
use std::thread;
use std::time::{Duration, Instant};

fn main() {
    let deadline = Instant::now() + Duration::from_millis(200);
    let mut joiner = DeadlineJoiner::new(deadline);

    for job in 0..4 {
        joiner.spawn(move || {
            thread::sleep(Duration::from_millis(40 * job));
            format!("job {job}")
        });
    }

    let summary = joiner.join_ready();
    println!("{} tasks finished on time", summary.completed_count());
    println!("{} tasks missed the deadline", summary.timed_out_count());

    for result in summary.completed {
        let task_id = result.task_id;
        let duration = result.duration();
        match result.outcome {
            TaskOutcome::Completed(value) => {
                println!("{value} completed in {:?}", duration)
            }
            TaskOutcome::Panicked(info) => {
                println!("task {task_id} panicked: {info}")
            }
        }
    }

    if !summary.timed_out.is_empty() {
        println!(
            "Still running: {:?}",
            summary
                .timed_out
                .iter()
                .map(|task| task.task_id)
                .collect::<Vec<_>>()
        );
    }
}