add primitives and syncs examples

Author: chaoyuepan

Cargo.toml

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

asyncwait/src/future.rs

@@ -0,0 +1,65 @@
+
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::task::Waker;
+use std::task::Poll;
+use std::task::Context;
+use std::time::Duration;
+use std::thread;
+use std::future::Future;
+use std::pin::Pin;
+
+
+pub struct TimerFuture {
+    shared_state: Arc<Mutex<SharedState>>,
+}
+
+/// Shared state between the future and the waiting thread
+struct SharedState {
+    completed: bool,
+    waker: Option<Waker>,
+}
+
+impl TimerFuture {
+    pub fn new(duration: Duration) -> TimerFuture {
+        let shared_state = Arc::new(Mutex::new(SharedState {
+            completed: false,
+            waker: None,
+        }));
+
+        let thread_shared_state = shared_state.clone();
+
+        thread::spawn(move || {
+            thread::sleep(duration);
+            let mut shared_state = thread_shared_state.lock().unwrap();
+            
+            shared_state.completed = true;
+            if let Some(waker) = shared_state.waker.take() {
+                waker.wake();
+            }
+        });
+
+        TimerFuture { shared_state }
+    }
+}
+
+impl Future for TimerFuture {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut shared_state = self.shared_state.lock().unwrap();
+
+        if shared_state.completed {
+            println!("TimerFuture completed");
+            Poll::Ready(())
+        } else {
+            shared_state.waker = Some(cx.waker().clone());
+            Poll::Pending
+        }
+    }
+}
+
+pub fn timefuture_async() {
+    let tf = TimerFuture::new(Duration::from_millis(1000));
+    smol::block_on(tf)
+}

asyncwait/src/lib.rs

@@ -1,6 +1,8 @@
 pub mod asyncio;
+pub mod future;
 
 pub use asyncio::*;
+pub use future::*;
 
 use futures::channel::mpsc;
 use futures::executor::{self, ThreadPool};

asyncwait/src/main.rs

@@ -7,6 +7,8 @@ fn main() {
     async_std();
     smol_async();
 
+    timefuture_async();
+    
     join();
     select();
 

collections/Cargo.toml

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

collections/src/lib.rs

@@ -0,0 +1,5 @@
+use collections;
+
+fn main() {
+    println!("Hello, world!");
+}

collections/src/main.rs

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

primitive/Cargo.toml

@@ -0,0 +1,19 @@
+// Box<T>, casually referred to as a ‘box’, provides the simplest form of heap allocation in Rust. 
+// Boxes provide ownership for this allocation, and drop their contents when they go out of scope. 
+// Boxes also ensure that they never allocate more than isize::MAX bytes.
+pub fn box_example() {
+    let b = Box::new(5);
+    println!("b = {}", b);
+}
+
+pub fn box_example2() {
+    #[derive(Debug)]
+    enum List<T> {
+        Cons(T, Box<List<T>>),
+        Nil,
+    }
+
+    let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
+    println!("{list:?}");
+}
+

primitive/src/box.rs

@@ -0,0 +1,167 @@
+#![allow(dead_code)]
+
+use std::cell::*;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+// Shareable mutable containers.
+// Shareable mutable containers exist to permit mutability in a controlled manner, even in the presence of aliasing.
+// Both Cell<T> and RefCell<T> allow doing this in a single-threaded way. However, neither Cell<T> nor RefCell<T> are thread safe (they do not implement Sync).
+// If you need to do aliasing and mutation between multiple threads it is possible to use Mutex<T>, RwLock<T> or atomic types.
+//
+// Cell<T> implements interior mutability by moving values in and out of the Cell<T>.
+// To use references instead of values, one must use the RefCell<T> type, acquiring a write lock before mutating.
+
+pub fn cell_example() {
+    struct SomeStruct {
+        regular_field: u8,
+        special_field: Cell<u8>,
+    }
+
+    // not mutable
+    let my_struct = SomeStruct {
+        regular_field: 0,
+        special_field: Cell::new(1),
+    };
+
+    let _ = my_struct.regular_field;
+    // my_struct.regular_field = 100;
+    my_struct.special_field.set(100);
+}
+
+pub fn refcell_example() {
+    #[allow(dead_code)]
+    struct SomeStruct {
+        regular_field: u8,
+        special_field: RefCell<u8>,
+    }
+
+    // not mutable
+    let my_struct = SomeStruct {
+        regular_field: 0,
+        special_field: RefCell::new(1),
+    };
+
+    // my_struct.regular_field = 100;
+    let mut special_field = (&my_struct.special_field).borrow_mut();
+    *special_field = 100;
+    drop(special_field);
+
+    println!("special_field = {}", my_struct.special_field.borrow());
+
+    (&my_struct).special_field.replace(200);
+    println!("special_field = {}", my_struct.special_field.borrow());
+}
+
+pub fn rc_refcell_example() {
+    let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));
+    // Create a new block to limit the scope of the dynamic borrow
+    {
+        let mut map: RefMut<_> = shared_map.borrow_mut();
+        map.insert("africa", 92388);
+        map.insert("kyoto", 11837);
+        map.insert("piccadilly", 11826);
+        map.insert("marbles", 38);
+    }
+
+    // Note that if we had not let the previous borrow of the cache fall out
+    // of scope then the subsequent borrow would cause a dynamic thread panic.
+    // This is the major hazard of using `RefCell`.
+    let total: i32 = shared_map.borrow().values().sum();
+    println!("{total}");
+}
+
+pub fn once_cell_example() {
+    let cell = OnceCell::new();
+    assert!(cell.get().is_none());
+
+    let value: &String = cell.get_or_init(|| "Hello, World!".to_string());
+    assert_eq!(value, "Hello, World!");
+    assert!(cell.get().is_some());
+}
+
+pub fn lazy_cell_example() {
+    let lazy: LazyCell<i32> = LazyCell::new(|| {
+        println!("initializing");
+        92
+    });
+    println!("one_cell ready");
+    println!("{}", *lazy);
+    println!("{}", *lazy);
+}
+
+pub fn myrc_example() {
+    let s = example::Rc::new("hello world");
+    let s1 = s.clone();
+
+    let v = s1.value();
+    println!("myrc value: {}", v);
+}
+
+pub mod example {
+    use std::cell::Cell;
+    use std::marker::PhantomData;
+    use std::process::abort;
+    use std::ptr::NonNull;
+
+    pub struct Rc<T: ?Sized> {
+        ptr: NonNull<RcBox<T>>,
+        phantom: PhantomData<RcBox<T>>,
+    }
+
+    impl<T> Rc<T> {
+        pub fn new(t: T) -> Self {
+            let ptr = Box::new(RcBox {
+                strong: Cell::new(1),
+                refcount: Cell::new(1),
+                value: t,
+            });
+            let ptr = NonNull::new(Box::into_raw(ptr)).unwrap();
+            Self {
+                ptr: ptr,
+                phantom: PhantomData,
+            }
+        }
+
+        pub fn value(&self) -> &T {
+            &self.inner().value
+        }
+    }
+
+
+    struct RcBox<T: ?Sized> {
+        strong: Cell<usize>,
+        refcount: Cell<usize>,
+        value: T,
+    }
+
+    impl<T: ?Sized> Clone for Rc<T> {
+        fn clone(&self) -> Rc<T> {
+            self.inc_strong();
+            Rc {
+                ptr: self.ptr,
+                phantom: PhantomData,
+            }
+        }
+    }
+
+    trait RcBoxPtr<T: ?Sized> {
+        fn inner(&self) -> &RcBox<T>;
+
+        fn strong(&self) -> usize {
+            self.inner().strong.get()
+        }
+
+        fn inc_strong(&self) {
+            self.inner()
+                .strong
+                .set(self.strong().checked_add(1).unwrap_or_else(|| abort()));
+        }
+    }
+
+    impl<T: ?Sized> RcBoxPtr<T> for Rc<T> {
+        fn inner(&self) -> &RcBox<T> {
+            unsafe { self.ptr.as_ref() }
+        }
+    }
+}