add chapter 06

Author: smallnest

.DS_Store

@@ -25,42 +25,44 @@ Introduces [async feature](asyncwait/src/main.rs).
 
 ### chapter 4: synchronization primitives
 
-Introduces synchronization primitives contains [containers](container_primitive/src/main.rs) and [primitives](sync_primitive/src/main.rs) in std lib.
+Introduces synchronization primitives contains [containers](container_primitive/src/main.rs) 
 
-### chapter 5: concurrency collections
+### chapter 5: basic concurrency primitives
+Introduction of basic concurrency [primitives](sync_primitive/src/main.rs) in std lib.
+
+### chapter 6: concurrency collections
 
 Introduces [concurrency collections](collections/src/main.rs) in std lib.
 
-### chapter 6: process
+### chapter 7: process
 
 Introduces starting and executing a new [process](process/src/main.rs) in the easy way.
 
-### chapter 7: channel
+### chapter 8: channel
 
 Introduces each [channels](channel/src/main.rs) such as mpsc, mpmc and broadcasters.
 
-### chapter 8: timer/ticker
+### chapter 9: timer/ticker
 
 Introduces [timer and ticker](timer_examples/src/main.rs).
 
-### chapter 9: parking_lot
+### chapter 10: parking_lot
 
 Introduces [parking_lot](parking_lot_examples/src/main.rs).
 
-### chapter 10: crossbeam
+### chapter 11: crossbeam
 
 Introduces [crossbeam](crossbeam_examples/src/main.rs).
 
-### chapter 11: rayon
+### chapter 12: rayon
 
 Introduces [rayon](rayon_examples/src/main.rs).
 
-### chapter 12: tokio
+### chapter 13: tokio
 
 Introduces [tokio](tokio_examples/src/main.rs).
 
-
-### chapter n: special
+### chapter 14: special
 
 some special synchronization primitives and concurrency libs only for special single purpose.
 

README.md

@@ -6,3 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+cuckoofilter = "0.5.0"
+dashmap = "5.5.3"
+evmap = "10.0.2"

book_cn/rust_concurrency_cookbook.pdf

@@ -1,5 +1,10 @@
-use std::{sync::{Arc, Mutex}, collections::HashMap};
+use cuckoofilter::CuckooFilter;
+use dashmap::DashMap;
 use std::collections::LinkedList;
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex},
+};
 
 pub fn common_thread_safe_collections() {
     let map: HashMap<i32, i32> = HashMap::new();
@@ -21,7 +26,6 @@ pub fn common_thread_safe_collections() {
     println!("HashMap: {:?}", *m.lock().unwrap());
 }
 
-
 pub fn common_thread_safe_vec() {
     let vec1 = vec![];
     let vec2 = Arc::new(Mutex::new(vec1));
@@ -39,7 +43,7 @@ pub fn common_thread_safe_vec() {
         handle.join().unwrap();
     }
 
-    println!("vec: {:?}",  vec2.lock().unwrap());
+    println!("vec: {:?}", vec2.lock().unwrap());
 }
 
 pub fn common_thread_safe_linkedlist() {
@@ -59,5 +63,74 @@ pub fn common_thread_safe_linkedlist() {
         handle.join().unwrap();
     }
 
-    println!("LinkedList: {:?}",  list2.lock().unwrap());
+    println!("LinkedList: {:?}", list2.lock().unwrap());
+}
+
+pub fn dashmap_example() {
+    let map = Arc::new(DashMap::new());
+    let mut handles = vec![];
+
+    for i in 0..10 {
+        let map = Arc::clone(&map);
+        handles.push(std::thread::spawn(move || {
+            map.insert(i, i);
+        }));
+    }
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    println!("DashMap: {:?}", map);
+}
+
+pub fn cuckoofilter_example() {
+    let value: &str = "hello world";
+
+    // Create cuckoo filter with default max capacity of 1000000 items
+    let mut cf = CuckooFilter::new();
+
+    // Add data to the filter
+    cf.add(value).unwrap();
+
+    // Lookup if data is in the filter
+    let success = cf.contains(value);
+    assert!(success);
+
+    // Test and add to the filter (if data does not exists then add)
+    let success = cf.test_and_add(value).unwrap();
+    assert!(!success);
+
+    // Remove data from the filter.
+    let success = cf.delete(value);
+    assert!(success);
+}
+
+pub fn evmap_example() {
+    let (book_reviews_r, book_reviews_w) = evmap::new();
+
+    // start some writers.
+    // since evmap does not support concurrent writes, we need
+    // to protect the write handle by a mutex.
+    let w = Arc::new(Mutex::new(book_reviews_w));
+    let writers: Vec<_> = (0..4)
+        .map(|i| {
+            let w = w.clone();
+            std::thread::spawn(move || {
+                let mut w = w.lock().unwrap();
+                w.insert(i, true);
+                w.refresh();
+            })
+        })
+        .collect();
+
+    // eventually we should see all the writes
+    while book_reviews_r.len() < 4 {
+       std::thread::yield_now();
+    }
+
+    // all the threads should eventually finish writing
+    for w in writers.into_iter() {
+        assert!(w.join().is_ok());
+    }
 }

collections/Cargo.toml

@@ -5,4 +5,7 @@ fn main() {
     common_thread_safe_vec();
     common_thread_safe_linkedlist();
 
+    dashmap_example();
+    cuckoofilter_example();
+    evmap_example();
 }