Complete exercise: threads_channels

exercise/threads_channels/src/main.rs

@@ -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,17 +37,16 @@ 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...
@@ -62,7 +61,7 @@ fn main() {
 
     // Thread A
     let handle_a = thread::spawn(move || {
-            sleep_ms(0);
+        sleep_ms(500);
         tx2.send("Thread A: 1").unwrap();
         sleep_ms(200);
         tx2.send("Thread A: 2").unwrap();
@@ -88,12 +87,46 @@ fn main() {
 
     // 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.")
 }