clean up and formatting

Author: Jade Wibbels

module2/data_race/src/main.rs

@@ -1,17 +1,19 @@
 // Mutex that protects the data vector, and then we spawn three threads
 //that each acquire a lock on the mutex and modify an element of the vector.
+// https://doc.rust-lang.org/std/sync/struct.Mutex.html
 
-use std::sync::Mutex;
+use std::sync::{Arc, Condvar, Mutex, RwLock};
 use std::thread;
 
-fn main() {
-    let data = Mutex::new(vec![1, 2, 3]);
+fn using_mutex() {
+    println!("Mutex Example");
+    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
 
     let handles: Vec<_> = (0..3)
         .map(|i| {
-            let data = data.lock().unwrap().clone();
+            let data = Arc::clone(&data);
             thread::spawn(move || {
-                let mut data = data;
+                let mut data = data.lock().unwrap();
                 data[i] += 1;
                 println!("{:?}", data);
             })
@@ -22,7 +24,72 @@ fn main() {
         handle.join().unwrap();
     }
 
-    println!("{:?}", data);
+    let data = data.lock().unwrap();
+    println!("Final data: {:?}", *data);
+}
+
+fn using_rwlock() {
+    println!("RwLock Example");
+    // Create an RwLock protecting a vector
+    let data = Arc::new(RwLock::new(vec![1, 2, 3]));
+
+    // Spawn three threads that each acquire a write lock on the RwLock and modify an element of the vector
+    let handles: Vec<_> = (0..3)
+        .map(|i| {
+            let data = Arc::clone(&data);
+            thread::spawn(move || {
+                let mut data = data.write().unwrap();
+                data[i] += 1;
+                println!("Thread {}: {:?}", i, *data);
+            })
+        })
+        .collect();
+
+    // Wait for all threads to finish
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    // Acquire a read lock to print the final state of the vector
+    let data = data.read().unwrap();
+
+    println!("Final data: {:?}", *data);
+}
+
+fn using_condvar() {
+    println!("Condvar Example");
+    let data = Arc::new((Mutex::new(vec![1, 2, 3]), Condvar::new()));
+    let mut handles = vec![];
+
+    for i in 0..3 {
+        let data = Arc::clone(&data);
+        let handle = thread::spawn(move || {
+            let (lock, cvar) = &*data;
+            let mut data = lock.lock().unwrap();
+            data[i] += 1;
+            println!("Thread {}: {:?}", i, *data);
+            cvar.notify_one();
+        });
+        handles.push(handle);
+    }
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    let (lock, cvar) = &*data;
+    let mut data = lock.lock().unwrap();
+    while data.iter().any(|&x| x == 1) {
+        data = cvar.wait(data).unwrap();
+    }
+
+    println!("Final data: {:?}", *data);
+}
+
+fn main() {
+    using_mutex();
+    using_rwlock();
+    using_condvar();
 }
 
 /*