Real-time executors with deterministic task routing and guaranteed ordering.
User-defined Executor:
struct MyExecutor {
id: usize,
}
impl LaneExecutor<usize> for MyExecutor {
fn execute(&self, task: usize) {
println!("{} received {}", self.id, task);
}
}
Using ThreadLanes: ``` let lanes = ThreadLanes::new(vec![ MyExecutor{id: 0}, MyExecutor{id: 1}, MyExecutor{id: 2}, ]);
lanes.send(0, 11); // send task=11 to thread lane 0 lanes.send(1, 12); // send task=12 to thread lane 1 lanes.send(1, 13); // send task=13 to thread lane 1 lanes.send(2, 14); // send task=14 to thread lane 2 lanes.send(2, 15); // send task=15 to thread lane 2 lanes.send(2, 16); // send task=16 to thread lane 2
// flush tasks lanes.flush(); ```
In the output, you'll notice that task ordering is preserved for each Executor, but is not preserved between Executors:
1 received 12
0 received 11
1 received 13
2 received 14
2 received 15
2 received 16
ThreadLanes are useful when you need deterministic task ordering through stateful Executors. This is in contrast to a thread pool, where the thread that executes a task is not deterministic.