add chapter 05

Author: smallnest

.DS_Store

@@ -7,3 +7,4 @@ edition = "2021"
 
 [dependencies]
 beef = "0.5.2"
+once_cell = "1.18.0"

book_cn/rust_concurrency_cookbook.pdf

@@ -6,4 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rand = "0.8.5"
+once_cell = "1.18.0"
+rand = "0.8.5"

container_primitive/Cargo.toml

@@ -1,3 +1,4 @@
+use core::time;
 use std::sync::Arc;
 use std::sync::Barrier;
 use std::thread;
@@ -21,6 +22,33 @@ pub fn barrier_example() {
         }));
     }
 
+    for handle in handles {
+        handle.join().unwrap();
+    }
+}
+
+pub fn barrier_recycle_example() {
+    let barrier = Arc::new(Barrier::new(10));
+    let mut handles = vec![];
+
+    for _ in 0..10 {
+        let barrier = barrier.clone();
+        handles.push(thread::spawn(move || {
+            println!("before wait1");
+            let dur = rand::thread_rng().gen_range(100..1000);
+            thread::sleep(std::time::Duration::from_millis(dur));
+
+            //step1
+            barrier.wait();
+            println!("after wait1");
+            thread::sleep(time::Duration::from_secs(1));
+
+            //step2
+            barrier.wait();
+            println!("after wait2");
+        }));
+    }
+
     for handle in handles {
         handle.join().unwrap();
     }

sync_primitive/Cargo.toml

@@ -0,0 +1,12 @@
+use std::sync::Exclusive;
+
+pub fn exclusive_lock_example() {
+    let mut exclusive = Exclusive::new(92);
+    println!("ready");
+    std::thread::spawn(move || {
+        let counter = exclusive.get_mut();
+        println!("{}", *counter);
+        *counter = 100;
+    }).join().unwrap();
+
+}

sync_primitive/src/barrier.rs

@@ -0,0 +1,29 @@
+use std::cell::LazyCell;
+use std::sync::LazyLock;
+
+pub fn lazy_cell_example() {
+    let lazy: LazyCell<i32> = LazyCell::new(|| {
+        println!("initializing");
+        92
+    });
+    println!("ready");
+    println!("{}", *lazy);
+    println!("{}", *lazy);
+}
+
+use std::collections::HashMap;
+static HASHMAP: LazyLock<HashMap<i32, String>> = LazyLock::new(|| {
+    println!("initializing");
+    let mut m = HashMap::new();
+    m.insert(13, "Spica".to_string());
+    m.insert(74, "Hoyten".to_string());
+    m
+});
+
+pub fn lazy_lock_example() {
+    println!("ready");
+    std::thread::spawn(|| {
+        println!("{:?}", HASHMAP.get(&13));
+    }).join().unwrap();
+    println!("{:?}", HASHMAP.get(&74));
+}

sync_primitive/src/exclusive.rs

@@ -1,4 +1,6 @@
 #![feature(sync_unsafe_cell)]
+#![feature(lazy_cell)]
+#![feature(exclusive_wrapper)]
 
 pub mod arc;
 pub mod mutex;
@@ -8,6 +10,8 @@ pub mod barrier;
 pub mod cond;
 pub mod mpsc;
 pub mod atomic;
+pub mod lazy;
+pub mod exclusive;
 
 pub use arc::*;
 pub use mutex::*;
@@ -16,4 +20,6 @@ pub use once::*;
 pub use barrier::*;
 pub use cond::*;
 pub use mpsc::*;
-pub use atomic::*;
+pub use atomic::*;
+pub use lazy::*;
+pub use exclusive::*;

sync_primitive/src/lazy.rs

@@ -8,14 +8,17 @@ fn main() {
     mutex_example1();
     mutex_example2_poison();
     mutex_example3_drop();
-
+    
     rwlock_example();
+    read_after_write();
 
     once_example();
     oncecell_example();
     oncelock_example();
+    once_cell_example();
 
     barrier_example();
+    barrier_recycle_example();
 
     condvar_example();
     condvar_example2();
@@ -25,4 +28,9 @@ fn main() {
 
     atomic_example();
     atomic_example2();
+
+    lazy_cell_example();
+    lazy_lock_example();
+
+    exclusive_lock_example();
 }

sync_primitive/src/lib.rs

@@ -84,3 +84,4 @@ pub fn mutex_example3_drop() {
 
     println!("Result: {:?}", res_mutex.lock().unwrap());
 }
+

sync_primitive/src/main.rs

@@ -53,4 +53,17 @@ pub fn oncelock_example() {
 	assert_eq!(value.unwrap().as_str(), "Hello, World!");
 
 	println!("OnceLock: {}", value.is_some())
+}
+
+use std::{sync::Mutex, collections::HashMap};
+use once_cell::sync::Lazy;
+static GLOBAL_DATA: Lazy<Mutex<HashMap<i32, String>>> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    m.insert(13, "Spica".to_string());
+    m.insert(74, "Hoyten".to_string());
+    Mutex::new(m)
+});
+
+pub fn once_cell_example() {
+	println!("{:?}", GLOBAL_DATA.lock().unwrap());
 }

sync_primitive/src/mutex.rs

@@ -35,4 +35,53 @@ pub fn rwlock_example() {
     }
 
     println!("RwLock: {}", *rwlock.read().unwrap());
-}   
+}   
+pub fn read_after_write() {
+    // 创建一个可共享的可变整数，使用RwLock包装
+    let counter = Arc::new(RwLock::new(0));
+
+    // 创建一个线程持有读锁
+    let read_handle = {
+        let counter = counter.clone();
+        thread::spawn(move || {
+            // 获取读锁
+            let num = counter.read().unwrap();
+            println!("Reader#1: {}", *num);
+
+            // 休眠模拟读取操作
+            thread::sleep(std::time::Duration::from_secs(10));
+        })
+    };
+
+    // 创建一个线程请求写锁
+    let write_handle = {
+        let counter = counter.clone();
+        thread::spawn(move || {
+            // 休眠一小段时间，确保读锁已经被获取
+            thread::sleep(std::time::Duration::from_secs(1));
+
+            // 尝试获取写锁
+            let mut num = counter.write().unwrap();
+            *num += 1;
+            println!("Writer : Incremented counter to {}",  *num);
+        })
+    };
+
+    // 创建一个线程请求读锁
+    let read_handle_2 = {
+        let counter = counter.clone();
+        thread::spawn(move || {
+            // 休眠一小段时间，确保写锁已经被获取
+            thread::sleep(std::time::Duration::from_secs(2));
+
+            // 尝试获取读锁
+            let num = counter.read().unwrap();
+            println!("Reader#2: {}", *num);
+        })
+    };
+
+    // 等待读取线程和写入线程完成
+    read_handle.join().unwrap();
+    write_handle.join().unwrap();
+    read_handle_2.join().unwrap();
+}