add more special examples

Author: smallnest

special/Cargo.toml

@@ -6,4 +6,12 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+async-lock = "2.5.0"
+concurrent-queue = "1.2.4"
+dashmap = "5.4.0"
+event-listener = "2.5.3"
 process_lock = "0.1.0"
+sharded-slab = "0.1.4"
+slab = "0.4.7"
+smol = "1.2.5"
+try-lock = "0.2.3"

special/src/lib.rs

@@ -1,7 +1,13 @@
 pub mod oslock;
 pub mod oneshot;
 pub mod map;
+pub mod primitive;
+pub mod notify;
+pub mod queue;
 
 pub use oslock::*;
 pub use oneshot::*;
-pub use map::*;
+pub use map::*;
+pub use primitive::*;
+pub use notify::*;
+pub use queue::*;

special/src/main.rs

@@ -1,5 +1,20 @@
 use special::*;
 
+
 fn main() {
     process_lock();
+
+    try_lock_example1();
+
+    sharded_slab_read();
+    sharded_slab_write();
+    sharded_slab_pool();
+    slab_example();
+
+    event_listener_example();
+
+    hashmap_example();
+    concurrent_queue_example();
+
+    async_lock_mutex();
 }

special/src/map.rs

@@ -0,0 +1,36 @@
+use std::sync::Arc;
+use std::thread;
+use dashmap::DashMap;
+
+pub fn hashmap_example() {
+    let map = Arc::new(DashMap::new());
+
+    let map1 = map.clone();
+    let whandle = thread::spawn(move || {
+        map1.insert(1, 2);
+        map1.insert(2, 3);
+    });
+
+
+    let map2 = map.clone();
+    let rhandle = thread::spawn(move || {
+        
+        loop {
+            if let Some(v) = map2.get(&1) {
+                println!("get value {} for key 1", *v);
+                break;
+            } 
+        }
+
+        loop {
+            if let Some(v) = map2.get(&2) {
+                println!("get value {} for key 2", *v);
+                break;
+            } 
+        }
+    });
+
+    whandle.join().unwrap();
+    rhandle.join().unwrap();
+    
+}

special/src/notify.rs

@@ -0,0 +1,47 @@
+use event_listener::Event;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::thread;
+use std::time::Duration;
+
+pub fn event_listener_example() {
+    let flag = Arc::new(AtomicBool::new(false));
+    let event = Arc::new(Event::new());
+
+    // Spawn a thread that will set the flag after 1 second.
+    thread::spawn({
+        let flag = flag.clone();
+        let event = event.clone();
+        move || {
+            // Wait for a second.
+            thread::sleep(Duration::from_secs(1));
+
+            // Set the flag.
+            flag.store(true, Ordering::SeqCst);
+
+            // Notify all listeners that the flag has been set.
+            event.notify(usize::MAX);
+        }
+    });
+
+    // Wait until the flag is set.
+    loop {
+        // Check the flag.
+        if flag.load(Ordering::SeqCst) {
+            break;
+        }
+
+        // Start listening for events.
+        let listener = event.listen();
+
+        // Check the flag again after creating the listener.
+        if flag.load(Ordering::SeqCst) {
+            break;
+        }
+
+        // Wait for a notification and continue the loop.
+        listener.wait();
+    }
+
+    println!("flag is set");
+}

special/src/oslock.rs

@@ -11,12 +11,12 @@ pub fn process_lock() {
             println!("lock success");
             break;
         }
-        if start.elapsed() > Duration::from_secs(10) {
+        if start.elapsed() > Duration::from_millis(500) {
             println!("lock timeout");
             break;
         }
         std::thread::sleep(Duration::from_millis(100));
     }
-    std::thread::sleep(Duration::from_secs(10));
+    std::thread::sleep(Duration::from_millis(500));
 
 }

special/src/primitive.rs

@@ -0,0 +1,20 @@
+use async_lock::*;
+use std::sync::Arc;
+
+pub fn async_lock_mutex() {
+    let lock = Arc::new(Mutex::new(0));
+
+    let lock1 = lock.clone();
+    smol::block_on(async {
+        let mut guard = lock1.lock().await;
+        *guard += 1;
+    });
+
+    let lock2 = lock.clone();
+    smol::block_on(async {
+        let guard = lock2.lock().await;
+        println!("lock2 {}", *guard);
+    });
+
+    
+}

special/src/primitive/async_lock_example.rs

@@ -0,0 +1,20 @@
+// Mutex
+// RWLock
+// wg
+// async-xxx
+// awaitgroup
+// usync
+
+
+// waitfor
+
+// atomig
+// atomicbox
+
+pub mod try_lock_examples;
+pub mod sharded_slab_example;
+pub mod async_lock_example;
+
+pub use try_lock_examples::*;
+pub use sharded_slab_example::*;
+pub use async_lock_example::*;

special/src/primitive/mod.rs

@@ -0,0 +1,78 @@
+use sharded_slab::Pool;
+use sharded_slab::Slab;
+
+use std::sync::{Arc, Mutex};
+
+// Slabs provide pre-allocated storage for many instances of a single data type.
+// When a large number of values of a single type are required, this can be more efficient than allocating each item individually.
+// Since the allocated items are the same size, memory fragmentation is reduced, and creating and removing new items can be very cheap.
+
+pub fn sharded_slab_read() {
+    let slab = Arc::new(Slab::new());
+
+    let slab2 = slab.clone();
+    let thread2 = std::thread::spawn(move || {
+        let key = slab2.insert("hello from thread two").unwrap();
+        assert_eq!(slab2.get(key).unwrap(), "hello from thread two");
+        key
+    });
+
+    let key1 = slab.insert("hello from thread one").unwrap();
+    assert_eq!(slab.get(key1).unwrap(), "hello from thread one");
+
+    // Wait for thread 2 to complete.
+    let key2 = thread2.join().unwrap();
+
+    // The item inserted by thread 2 remains in the slab.
+    assert_eq!(slab.get(key2).unwrap(), "hello from thread two");
+}
+
+pub fn sharded_slab_write() {
+    let slab = Arc::new(Slab::new());
+
+    let key = slab
+        .insert(Mutex::new(String::from("hello world")))
+        .unwrap();
+
+    let slab2 = slab.clone();
+    let thread2 = std::thread::spawn(move || {
+        let hello = slab2.get(key).expect("item missing");
+        let mut hello = hello.lock().expect("mutex poisoned");
+        *hello = String::from("hello everyone!");
+    });
+
+    thread2.join().unwrap();
+
+    let hello = slab.get(key).expect("item missing");
+    let hello = hello.lock().expect("mutex poisoned");
+    assert_eq!(hello.as_str(), "hello everyone!");
+}
+
+pub fn sharded_slab_pool() {
+    let pool: Pool<String> = Pool::new();
+
+    let mut guard = pool.create().unwrap();
+    let key = guard.key();
+    guard.push_str("hello world");
+
+    drop(guard); // release the guard, allowing immutable access.
+    assert_eq!(pool.get(key).unwrap(), String::from("hello world"));
+
+    // Mark this entry to be cleared.
+    pool.clear(key);
+    // The cleared entry is no longer available in the pool
+    assert!(pool.get(key).is_none());
+}
+
+pub fn slab_example() {
+    let mut slab = slab::Slab::new();
+
+    let hello = slab.insert("hello");
+    let world = slab.insert("world");
+
+    assert_eq!(slab[hello], "hello");
+    assert_eq!(slab[world], "world");
+
+    slab[world] = "earth";
+    assert_eq!(slab[world], "earth");
+}

special/src/primitive/sharded_slab_example.rs

@@ -0,0 +1,31 @@
+use std::sync::Arc;
+use try_lock::TryLock;
+
+pub fn try_lock_example1() {
+    // a thing we want to share
+    struct Widget {
+        name: String,
+    }
+
+    // lock it up!
+    let widget1 = Arc::new(TryLock::new(Widget {
+        name: "Spanner".into(),
+    }));
+
+    let widget2 = widget1.clone();
+
+    // mutate the widget
+    let mut locked = widget1.try_lock().expect("example isn't locked yet");
+    locked.name.push_str(" Bundle");
+
+    // hands off, buddy
+    let not_locked = widget2.try_lock();
+    assert!(not_locked.is_none(), "widget1 has the lock");
+
+    // ok, you can have it
+    drop(locked);
+
+    let locked2 = widget2.try_lock().expect("widget1 lock is released");
+
+    assert_eq!(locked2.name, "Spanner Bundle");
+}

special/src/primitive/try_lock_examples.rs

@@ -0,0 +1,29 @@
+use concurrent_queue::ConcurrentQueue;
+use std::thread;
+use std::sync::Arc;
+
+pub fn concurrent_queue_example() {
+    let q = Arc::new(ConcurrentQueue::unbounded());
+
+    let q1 = q.clone();
+    let whandle = thread::spawn(move || {
+        for i in 0..10 {
+            q1.push(i).unwrap();
+        }
+    });
+
+    let q2 = q.clone();
+    let rhandle = thread::spawn(move || {
+        loop {
+            if let Ok(v) = q2.pop() {
+                println!("get value {}", v);
+            } else {
+                println!("queue closed");
+                break;
+            }
+        }
+    });
+
+    whandle.join().unwrap();
+    rhandle.join().unwrap();
+}