mirror of
https://github.com/rust-lang/rustlings.git
synced 2026-05-15 17:58:44 +00:00
91fd773859
- Remove confusing use of atomics. Use return values of async tasks instead, to ensure all tasks are awaited. - Remove use of `println!()`, which uses a global lock and cannot be executed in parallel.
43 lines
1.6 KiB
Rust
43 lines
1.6 KiB
Rust
// Alice is an elementary school teacher who needs to calculate the mean test
|
|
// score for three classes she teaches. Instead of calculating them one after
|
|
// the other, she decides to ask her friends Bob and Catherine for help. Working
|
|
// together, they can finish the job much faster.
|
|
//
|
|
// Let's simulate this using asynchronous programming. Each person is
|
|
// represented as an asynchronous task, which can be executed concurrently (i.e.
|
|
// they can be doing the calculations at the same time).
|
|
|
|
fn main() {
|
|
// Async tasks need to be executed by a "runtime", which is not provided by
|
|
// Rust's standard library. Here, we use the mainstream runtime `tokio`.
|
|
let rt = tokio::runtime::Builder::new_current_thread()
|
|
.build()
|
|
.unwrap();
|
|
|
|
let scores_class_a = &[83, 77, 92];
|
|
let scores_class_b = &[84, 88, 96];
|
|
let scores_class_c = &[71, 83, 76];
|
|
|
|
let alice = rt.spawn(calculate_mean_score(scores_class_a));
|
|
let bob = rt.spawn(calculate_mean_score(scores_class_b));
|
|
let catherine = rt.spawn(calculate_mean_score(scores_class_c));
|
|
|
|
// Block the runtime on a task that awaits all three calculations.
|
|
let [mean_score_a, mean_score_b, mean_score_c]: [usize; _] = rt.block_on(async {
|
|
[
|
|
alice.await.unwrap(),
|
|
bob.await.unwrap(),
|
|
catherine.await.unwrap(),
|
|
]
|
|
});
|
|
|
|
assert_eq!(mean_score_a, 84);
|
|
assert_eq!(mean_score_b, 89);
|
|
assert_eq!(mean_score_c, 76);
|
|
}
|
|
|
|
async fn calculate_mean_score(score_list: &[usize]) -> usize {
|
|
let score_sum: usize = score_list.iter().sum();
|
|
score_sum / score_list.len()
|
|
}
|