feat: Add threads2.rs exercise

Add an exercise centered around threads and the mspc library.

exercises/threads/threads2.rs

@@ -0,0 +1,64 @@
+// threads2.rs
+// Make this compile! Execute `rustlings hint threads2` for hints :)
+
+// I AM NOT DONE
+
+use std::sync::mpsc;
+use std::sync::Arc;
+use std::thread;
+use std::time::Duration;
+
+struct Queue {
+    length: u32,
+    first_half: Vec<u32>,
+    second_half: Vec<u32>,
+}
+
+impl Queue {
+    fn new() -> Self {
+        Queue {
+            length: 10,
+            first_half: vec![1, 2, 3, 4, 5],
+            second_half: vec![6, 7, 8, 9, 10],
+        }
+    }
+}
+
+fn send_tx(q: Queue, tx: mpsc::Sender<u32>) -> () {
+    let qc = Arc::new(q);
+    let qc1 = qc.clone();
+    let qc2 = qc.clone();
+
+    thread::spawn(move || {
+        for val in &qc1.first_half {
+            println!("sending {:?}", val);
+            tx.send(*val).unwrap();
+            thread::sleep(Duration::from_secs(1));
+        }
+    });
+
+    thread::spawn(move || {
+        for val in &qc2.second_half {
+            println!("sending {:?}", val);
+            tx.send(*val).unwrap();
+            thread::sleep(Duration::from_secs(1));
+        }
+    });
+}
+
+fn main() {
+    let (tx, rx) = mpsc::channel();
+    let queue = Queue::new();
+    let queue_length = queue.length;
+
+    send_tx(queue, tx);
+
+    let mut total_received: u32 = 0;
+    for received in rx {
+        println!("Got: {}", received);
+        total_received += 1;
+    }
+
+    println!("total numbers received: {}", total_received);
+    assert_eq!(total_received, queue_length)
+}

info.toml

@@ -878,6 +878,22 @@ If you've learned from the sample solutions, I encourage you to come
 back to this exercise and try it again in a few days to reinforce
 what you've learned :)"""
 
+[[exercises]]
+name = "threads2"
+path = "exercises/threads/threads2.rs"
+mode = "compile"
+hint = """
+An alternate way to handle concurrency between threads is to use
+a mpsc (multiple producer, single consumer) channel to communicate.
+With both a sending end and a receiving end, it's possible to
+send values in one thread and receieve them in another.
+
+Multiple producers are possibile by using clone() to create a duplicate
+of the original sending end.
+
+See https://doc.rust-lang.org/book/ch16-02-message-passing.html for more info.
+"""
+
 # MACROS
 
 [[exercises]]