rust/ultimate_rust2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Complete exercise: threads_channels

Browse Source
This commit is contained in:
Kishan Takoordyal
2026-05-26 14:38:45 +04:00
parent 621fb6bb59
commit 76cb232b1e
1 changed files with 74 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
exercise/threads_channels/src/main.rs
View File

@@ -22,8 +22,8 @@ fn main() {
// join handle in a variable called `handle`. Once you've done this you should be able to run
// the code and see the output from the child thread's expensive sum in the middle of the main
// thread's processing of letters.
//
//let handle = ...
let handle = thread::spawn(|| expensive_sum(my_vector));
// While the child thread is running, the main thread will also do some work
for letter in vec!["a", "b", "c", "d", "e", "f"] {
@@ -37,63 +37,96 @@ fn main() {
// to a variable named `result`
// - Get the i32 out of `result` and store it in a `sum` variable.
// let result =
// let sum =
// println!("The child thread's expensive sum is {}", sum);
let result = handle.join();
let sum = result.unwrap();
println!("The child thread's expensive sum is {}", sum);
// 3. Time for some fun with channels!
// - Uncomment the block comment below (Find and remove the `/*` and `*/`).
// - Create variables `tx` and `rx` and assign them to the sending and receiving ends of an
// unbounded channel. Hint: An unbounded channel can be created with `channel::unbounded()`
/*
// let ...
let (tx, rx) = channel::unbounded();
// Cloning a channel makes another variable connected to that end of the channel so that you can
// send it to another thread. We want another variable that can be used for sending...
let tx2 = tx.clone();
// Cloning a channel makes another variable connected to that end of the channel so that you can
// send it to another thread. We want another variable that can be used for sending...
let tx2 = tx.clone();
// 4. Examine the flow of execution of "Thread A" and "Thread B" below. Do you see how their
// output will mix with each other?
// - Run this code. Notice the order of output from Thread A and Thread B.
// - Increase the value passed to the first `sleep_ms()` call in Thread A so that both the
// Thread B outputs occur *before* Thread A outputs anything.
// - Run the code again and make sure the output comes in a different order.
// 4. Examine the flow of execution of "Thread A" and "Thread B" below. Do you see how their
// output will mix with each other?
// - Run this code. Notice the order of output from Thread A and Thread B.
// - Increase the value passed to the first `sleep_ms()` call in Thread A so that both the
// Thread B outputs occur *before* Thread A outputs anything.
// - Run the code again and make sure the output comes in a different order.
// Thread A
let handle_a = thread::spawn(move || {
sleep_ms(0);
tx2.send("Thread A: 1").unwrap();
sleep_ms(200);
tx2.send("Thread A: 2").unwrap();
});
// Thread A
let handle_a = thread::spawn(move || {
sleep_ms(500);
tx2.send("Thread A: 1").unwrap();
sleep_ms(200);
tx2.send("Thread A: 2").unwrap();
});
sleep_ms(100); // Make sure Thread A has time to get going before we spawn Thread B
sleep_ms(100); // Make sure Thread A has time to get going before we spawn Thread B
// Thread B
let handle_b = thread::spawn(move || {
sleep_ms(0);
tx.send("Thread B: 1").unwrap();
sleep_ms(200);
tx.send("Thread B: 2").unwrap();
});
// Thread B
let handle_b = thread::spawn(move || {
sleep_ms(0);
tx.send("Thread B: 1").unwrap();
sleep_ms(200);
tx.send("Thread B: 2").unwrap();
});
// Using a Receiver channel as an iterator is a convenient way to get values until the channel
// gets closed. A Receiver channel is automatically closed once all Sender channels have been
// closed. Both our threads automatically close their Sender channels when they exit and the
// destructors for the channels get automatically called.
for msg in rx {
println!("Main thread: Received {}", msg);
}
// Using a Receiver channel as an iterator is a convenient way to get values until the channel
// gets closed. A Receiver channel is automatically closed once all Sender channels have been
// closed. Both our threads automatically close their Sender channels when they exit and the
// destructors for the channels get automatically called.
for msg in rx {
println!("Main thread: Received {}", msg);
}
// 5. Oops, we forgot to join "Thread A" and "Thread B". That's bad hygiene!
// - Use the thread handles to join both threads without getting any compiler warnings.
*/
// 5. Oops, we forgot to join "Thread A" and "Thread B". That's bad hygiene!
// - Use the thread handles to join both threads without getting any compiler warnings.
let _ = handle_a.join();
let _ = handle_b.join();
// Challenge: Make two child threads and give them each a receiving end to a channel. From the
// main thread loop through several values and print each out and then send it to the channel.
// On the child threads print out the values you receive. Close the sending side in the main
// thread by calling `drop(tx)` (assuming you named your sender channel variable `tx`). Join
// the child threads.
let (tx, rx) = channel::unbounded();
let rx2 = rx.clone();
let thread_a_handle = thread::spawn(move || {
for n in rx {
println!("Thread A received: {}", n);
sleep_ms(10);
}
});
let thread_b_handle = thread::spawn(move || {
for n in rx2 {
println!("Thread B received: {}", n);
sleep_ms(10);
}
});
for number in vec![
1,
2,
3,
4,
5,
] {
println!("NUMBER: {}", number);
let _ = tx.send(number);
}
drop(tx);
let _ = thread_a_handle.join();
let _ = thread_b_handle.join();
println!("Main thread: Exiting.")
}