add chapter 11

Author: smallnest

.DS_Store

@@ -0,0 +1,25 @@
+use crossbeam::atomic::AtomicCell;
+
+
+pub fn atomic_cell_example() {
+    let a = AtomicCell::new(0i32);
+
+    a.store(1);
+    assert_eq!(a.load(), 1);
+    
+
+    assert_eq!(a.compare_exchange(1, 2), Ok(1));
+    assert_eq!(a.fetch_add(1), 2);
+    assert_eq!(a.load(), 3);
+    assert_eq!(a.swap(100), 3);
+    assert_eq!(a.load(), 100);
+    assert_eq!(a.into_inner(), 100);
+
+    let a = AtomicCell::new(100i32);
+    let v = a.take();
+    assert_eq!(v, 100);
+    assert_eq!(a.load(), 0);
+}
+
+
+

.history/crossbeam_examples/src/atomics_20230212213756.rs

@@ -0,0 +1,47 @@
+use crossbeam::atomic::AtomicCell;
+
+
+pub fn atomic_cell_example() {
+    let a = AtomicCell::new(0i32);
+
+    a.store(1);
+    assert_eq!(a.load(), 1);
+    
+
+    assert_eq!(a.compare_exchange(1, 2), Ok(1));
+    assert_eq!(a.fetch_add(1), 2);
+    assert_eq!(a.load(), 3);
+    assert_eq!(a.swap(100), 3);
+    assert_eq!(a.load(), 100);
+    assert_eq!(a.into_inner(), 100);
+
+    let a = AtomicCell::new(100i32);
+    let v = a.take();
+    assert_eq!(v, 100);
+    assert_eq!(a.load(), 0);
+}
+
+
+pub fn atomic_consume_example() {
+    use crossbeam::atomic::AtomicConsume;
+
+let data = vec![1, 2, 3, 4, 5];
+let shared_data = AtomicConsume::new(data);
+
+let mut join_handles = Vec::new();
+
+for _ in 0..5 {
+    let shared_data = shared_data.clone();
+    
+    join_handles.push(thread::spawn(move || {
+        let x = shared_data.load_consume();
+        if let Some(v) = x {
+            println!("Consumed: {}", v); 
+        }
+    }));
+} 
+
+for handle in join_handles {
+    handle.join().unwrap();
+}
+}

.history/crossbeam_examples/src/atomics_20231112182516.rs

@@ -0,0 +1,44 @@
+use crossbeam::atomic::AtomicCell;
+
+pub fn atomic_cell_example() {
+    let a = AtomicCell::new(0i32);
+
+    a.store(1);
+    assert_eq!(a.load(), 1);
+
+    assert_eq!(a.compare_exchange(1, 2), Ok(1));
+    assert_eq!(a.fetch_add(1), 2);
+    assert_eq!(a.load(), 3);
+    assert_eq!(a.swap(100), 3);
+    assert_eq!(a.load(), 100);
+    assert_eq!(a.into_inner(), 100);
+
+    let a = AtomicCell::new(100i32);
+    let v = a.take();
+    assert_eq!(v, 100);
+    assert_eq!(a.load(), 0);
+}
+
+pub fn atomic_consume_example() {
+    use crossbeam::atomic::AtomicConsume;
+
+    let data = vec![1, 2, 3, 4, 5];
+    let shared_data = AtomicConsume::new(data);
+
+    let mut join_handles = Vec::new();
+
+    for _ in 0..5 {
+        let shared_data = shared_data.clone();
+
+        join_handles.push(thread::spawn(move || {
+            let x = shared_data.load_consume();
+            if let Some(v) = x {
+                println!("Consumed: {}", v);
+            }
+        }));
+    }
+
+    for handle in join_handles {
+        handle.join().unwrap();
+    }
+}

.history/crossbeam_examples/src/atomics_20231112182521.rs

@@ -0,0 +1,45 @@
+use crossbeam::atomic::{AtomicCell,AtomicConsume};
+use std::thread;
+
+pub fn atomic_cell_example() {
+    let a = AtomicCell::new(0i32);
+
+    a.store(1);
+    assert_eq!(a.load(), 1);
+
+    assert_eq!(a.compare_exchange(1, 2), Ok(1));
+    assert_eq!(a.fetch_add(1), 2);
+    assert_eq!(a.load(), 3);
+    assert_eq!(a.swap(100), 3);
+    assert_eq!(a.load(), 100);
+    assert_eq!(a.into_inner(), 100);
+
+    let a = AtomicCell::new(100i32);
+    let v = a.take();
+    assert_eq!(v, 100);
+    assert_eq!(a.load(), 0);
+}
+
+pub fn atomic_consume_example() {
+    use crossbeam::atomic::AtomicConsume;
+
+    let data = vec![1, 2, 3, 4, 5];
+    let shared_data = AtomicConsume::new(data);
+
+    let mut join_handles = Vec::new();
+
+    for _ in 0..5 {
+        let shared_data = shared_data.clone();
+
+        join_handles.push(thread::spawn(move || {
+            let x = shared_data.load_consume();
+            if let Some(v) = x {
+                println!("Consumed: {}", v);
+            }
+        }));
+    }
+
+    for handle in join_handles {
+        handle.join().unwrap();
+    }
+}

.history/crossbeam_examples/src/atomics_20231112182629.rs

@@ -0,0 +1,43 @@
+use crossbeam::atomic::{AtomicCell,AtomicConsume};
+use std::thread;
+
+pub fn atomic_cell_example() {
+    let a = AtomicCell::new(0i32);
+
+    a.store(1);
+    assert_eq!(a.load(), 1);
+
+    assert_eq!(a.compare_exchange(1, 2), Ok(1));
+    assert_eq!(a.fetch_add(1), 2);
+    assert_eq!(a.load(), 3);
+    assert_eq!(a.swap(100), 3);
+    assert_eq!(a.load(), 100);
+    assert_eq!(a.into_inner(), 100);
+
+    let a = AtomicCell::new(100i32);
+    let v = a.take();
+    assert_eq!(v, 100);
+    assert_eq!(a.load(), 0);
+}
+
+pub fn atomic_consume_example() {
+    let data = vec![1, 2, 3, 4, 5];
+    let shared_data = AtomicConsume::new(data);
+
+    let mut join_handles = Vec::new();
+
+    for _ in 0..5 {
+        let shared_data = shared_data.clone();
+
+        join_handles.push(thread::spawn(move || {
+            let x = shared_data.load_consume();
+            if let Some(v) = x {
+                println!("Consumed: {}", v);
+            }
+        }));
+    }
+
+    for handle in join_handles {
+        handle.join().unwrap();
+    }
+}

.history/crossbeam_examples/src/atomics_20231112182653.rs

@@ -0,0 +1,21 @@
+use crossbeam::atomic::{AtomicCell,AtomicConsume};
+use std::thread;
+
+pub fn atomic_cell_example() {
+    let a = AtomicCell::new(0i32);
+
+    a.store(1);
+    assert_eq!(a.load(), 1);
+
+    assert_eq!(a.compare_exchange(1, 2), Ok(1));
+    assert_eq!(a.fetch_add(1), 2);
+    assert_eq!(a.load(), 3);
+    assert_eq!(a.swap(100), 3);
+    assert_eq!(a.load(), 100);
+    assert_eq!(a.into_inner(), 100);
+
+    let a = AtomicCell::new(100i32);
+    let v = a.take();
+    assert_eq!(v, 100);
+    assert_eq!(a.load(), 0);
+}

.history/crossbeam_examples/src/atomics_20231112182743.rs

@@ -0,0 +1,20 @@
+use crossbeam::atomic::{AtomicCell,};
+
+pub fn atomic_cell_example() {
+    let a = AtomicCell::new(0i32);
+
+    a.store(1);
+    assert_eq!(a.load(), 1);
+
+    assert_eq!(a.compare_exchange(1, 2), Ok(1));
+    assert_eq!(a.fetch_add(1), 2);
+    assert_eq!(a.load(), 3);
+    assert_eq!(a.swap(100), 3);
+    assert_eq!(a.load(), 100);
+    assert_eq!(a.into_inner(), 100);
+
+    let a = AtomicCell::new(100i32);
+    let v = a.take();
+    assert_eq!(v, 100);
+    assert_eq!(a.load(), 0);
+}

.history/crossbeam_examples/src/atomics_20231112182751.rs

@@ -0,0 +1,20 @@
+use crossbeam::atomic::{AtomicCell};
+
+pub fn atomic_cell_example() {
+    let a = AtomicCell::new(0i32);
+
+    a.store(1);
+    assert_eq!(a.load(), 1);
+
+    assert_eq!(a.compare_exchange(1, 2), Ok(1));
+    assert_eq!(a.fetch_add(1), 2);
+    assert_eq!(a.load(), 3);
+    assert_eq!(a.swap(100), 3);
+    assert_eq!(a.load(), 100);
+    assert_eq!(a.into_inner(), 100);
+
+    let a = AtomicCell::new(100i32);
+    let v = a.take();
+    assert_eq!(v, 100);
+    assert_eq!(a.load(), 0);
+}

.history/crossbeam_examples/src/atomics_20231112182753.rs

@@ -0,0 +1,20 @@
+use crossbeam::atomic::AtomicCell;
+
+pub fn atomic_cell_example() {
+    let a = AtomicCell::new(0i32);
+
+    a.store(1);
+    assert_eq!(a.load(), 1);
+
+    assert_eq!(a.compare_exchange(1, 2), Ok(1));
+    assert_eq!(a.fetch_add(1), 2);
+    assert_eq!(a.load(), 3);
+    assert_eq!(a.swap(100), 3);
+    assert_eq!(a.load(), 100);
+    assert_eq!(a.into_inner(), 100);
+
+    let a = AtomicCell::new(100i32);
+    let v = a.take();
+    assert_eq!(v, 100);
+    assert_eq!(a.load(), 0);
+}

.history/crossbeam_examples/src/atomics_20231112182758.rs

@@ -0,0 +1,21 @@
+use crossbeam_examples::*;
+fn main() {
+    atomic_cell_example();
+
+    crossbeam_deque_example();  
+    arrayqueue_example();
+    segqueue_example();
+    
+    unbounded_channel_example();
+    bounded_channel_example();
+    channel_iter_example();
+    channel_select_example();
+    channel_extra_example();
+    sharded_lock_example();
+    waitgroup_example();
+    parker_example();
+
+    backoff_example();
+    cachepadded_example();
+    scope_example();
+}

.history/crossbeam_examples/src/main_20230212213756.rs

@@ -0,0 +1,22 @@
+use crossbeam_examples::*;
+fn main() {
+    atomic_cell_example();
+    atomic_consume_example();
+
+    crossbeam_deque_example();  
+    arrayqueue_example();
+    segqueue_example();
+    
+    unbounded_channel_example();
+    bounded_channel_example();
+    channel_iter_example();
+    channel_select_example();
+    channel_extra_example();
+    sharded_lock_example();
+    waitgroup_example();
+    parker_example();
+
+    backoff_example();
+    cachepadded_example();
+    scope_example();
+}

.history/crossbeam_examples/src/main_20231112182529.rs

@@ -0,0 +1,24 @@
+use crossbeam_examples::*;
+use std::thread;
+
+fn main() {
+    atomic_cell_example();
+    atomic_consume_example();
+
+    crossbeam_deque_example();  
+    arrayqueue_example();
+    segqueue_example();
+    
+    unbounded_channel_example();
+    bounded_channel_example();
+    channel_iter_example();
+    channel_select_example();
+    channel_extra_example();
+    sharded_lock_example();
+    waitgroup_example();
+    parker_example();
+
+    backoff_example();
+    cachepadded_example();
+    scope_example();
+}

.history/crossbeam_examples/src/main_20231112182557.rs

@@ -0,0 +1,23 @@
+use crossbeam_examples::*;
+
+fn main() {
+    atomic_cell_example();
+    atomic_consume_example();
+
+    crossbeam_deque_example();  
+    arrayqueue_example();
+    segqueue_example();
+    
+    unbounded_channel_example();
+    bounded_channel_example();
+    channel_iter_example();
+    channel_select_example();
+    channel_extra_example();
+    sharded_lock_example();
+    waitgroup_example();
+    parker_example();
+
+    backoff_example();
+    cachepadded_example();
+    scope_example();
+}