add parking_lot examples

Author: smallnest

Cargo.toml

@@ -1,2 +1,2 @@
 [workspace]
-members = ["thread", "pool", "asyncwait", "primitive", "collections", "process", "syncs", "channel","special"]
+members = ["thread", "pool", "asyncwait", "primitive", "collections", "process", "syncs", "channel","parking_lot_examples", "special"]

README.md

@@ -15,7 +15,7 @@
 
 ## chapter 7: channel
 
-## chapter 8: xxxx
+## chapter 8: parking_lot
 
 ## chapter 9: xxxx
 

parking_lot_examples/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "parking_lot_examples"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+parking_lot = "0.12.1"

parking_lot_examples/src/lib.rs

@@ -0,0 +1,170 @@
+use std::sync::{mpsc::channel, Arc};
+use std::thread;
+
+use parking_lot::RwLock;
+use parking_lot::{FairMutex, Mutex, Once, ReentrantMutex};
+
+pub fn mutex_example() {
+    const N: usize = 10;
+
+    let data = Arc::new(Mutex::new(0));
+    let data2 = &data.clone();
+
+    let (tx, rx) = channel();
+    for _ in 0..10 {
+        let (data, tx) = (Arc::clone(&data), tx.clone());
+        thread::spawn(move || {
+            // The shared state can only be accessed once the lock is held.
+            // Our non-atomic increment is safe because we're the only thread
+            // which can access the shared state when the lock is held.
+            let mut data = data.lock();
+            *data += 1;
+            if *data == N {
+                tx.send(()).unwrap();
+            }
+            // the lock is unlocked here when `data` goes out of scope.
+        });
+    }
+
+    rx.recv().unwrap();
+
+    println!("mutex_example: {}", data2.lock());
+}
+
+pub fn mutex_example2() {
+    const N: usize = 10;
+
+    let mutex = Arc::new(Mutex::new(()));
+
+    let handles: Vec<_> = (0..N)
+        .map(|i| {
+            let mutex = Arc::clone(&mutex);
+            thread::spawn(move || {
+                let _lock = mutex.lock();
+                println!("thread {} done", i);
+            })
+        })
+        .collect();
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    println!("mutex_example2: done");
+}
+
+pub fn fairmutex_example() {
+    const N: usize = 10;
+
+    let data = Arc::new(FairMutex::new(0));
+
+    let (tx, rx) = channel();
+    for _ in 0..10 {
+        let (data, tx) = (Arc::clone(&data), tx.clone());
+        thread::spawn(move || {
+            // The shared state can only be accessed once the lock is held.
+            // Our non-atomic increment is safe because we're the only thread
+            // which can access the shared state when the lock is held.
+            let mut data = data.lock();
+            *data += 1;
+            if *data == N {
+                tx.send(()).unwrap();
+            }
+            // the lock is unlocked here when `data` goes out of scope.
+        });
+    }
+
+    rx.recv().unwrap();
+
+    println!("fairmutex_example: done");
+}
+
+pub fn rwmutex_example() {
+    const N: usize = 10;
+
+    let lock = Arc::new(RwLock::new(5));
+
+    let handles: Vec<_> = (0..N)
+        .map(|i| {
+            let lock = Arc::clone(&lock);
+            thread::spawn(move || {
+                if i % 2 == 0 {
+                    let mut num = lock.write();
+                    *num += 1;
+                } else {
+                    let num = lock.read();
+                    println!("thread {} read {}", i, num);
+                }
+            })
+        })
+        .collect();
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    println!("rwmutex_example: {}", lock.read());
+}
+pub fn reentrantmutex_example() {
+    let lock = ReentrantMutex::new(());
+
+    reentrant(&lock, 10);
+
+    println!("reentrantMutex_example: done");
+}
+
+fn reentrant(lock: &ReentrantMutex<()>, i: usize) {
+    if i == 0 {
+        return;
+    }
+
+    let _lock = lock.lock();
+    reentrant(lock, i - 1);
+}
+
+pub fn once_example() {
+    static mut VAL: usize = 0;
+    static INIT: Once = Once::new();
+    fn get_cached_val() -> usize {
+        unsafe {
+            INIT.call_once(|| {
+                println!("initializing once");
+                thread::sleep(std::time::Duration::from_secs(1));
+                VAL = 100;
+            });
+            VAL
+        }
+    }
+
+
+    let handle = thread::spawn(|| {
+        println!("thread 1 get_cached_val: {}", get_cached_val());
+    });
+
+    println!("get_cached_val: {}", get_cached_val());
+
+    handle.join().unwrap();
+}
+
+
+pub fn condvar_example() {
+    use std::sync::Condvar;
+    use std::sync::Mutex;
+
+    let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    let pair2 = Arc::clone(&pair);
+
+    thread::spawn(move || {
+        let (lock, cvar) = &*pair2;
+        let mut started = lock.lock().unwrap();
+        *started = true;
+        cvar.notify_one();
+    });
+
+    let (lock, cvar) = &*pair;
+    let mut started = lock.lock().unwrap();
+    while !*started {
+        started = cvar.wait(started).unwrap(); // block until notified
+    }
+    println!("condvar_example: done");
+}

parking_lot_examples/src/main.rs

@@ -0,0 +1,15 @@
+use parking_lot_examples::*;
+
+fn main() {
+    mutex_example();
+    mutex_example2();
+    fairmutex_example();
+
+    rwmutex_example();
+
+    reentrantmutex_example();
+
+    once_example();
+
+    condvar_example();
+}

thread/src/lib.rs

@@ -6,8 +6,8 @@ pub use threads::*;
 pub fn panic_example() {
     println!("Hello, world!");
 
-    let h = thread::spawn(|| {
-        thread::sleep_ms(1000);
+    let h = std::thread::spawn(|| {
+        std::thread::sleep(std::time::Duration::from_millis(1000));
         panic!("boom");
     });