Concurrency and Async

use std::thread;
let h = thread::spawn(|| 1 + 1);
h.join().unwrap()  // 2

use std::sync::mpsc;
let (tx, rx) = mpsc::channel();
tx.send(5).unwrap();
rx.recv().unwrap()  // 5

use std::sync::Mutex;
let m = Mutex::new(1);
{
    let mut g = m.lock().unwrap();
    *g += 1;
}
*m.lock().unwrap()  // 2

use std::sync::Arc;
let a = Arc::new(1);
let b = Arc::clone(&a);
*b  // 1

async fn add(a: i32, b: i32) -> i32 { a + b }
// poll with a runtime: tokio::runtime or block_on
// conceptual: add(2, 3).await == 5

// #[tokio::main]
// async fn main() {
//     let h = tokio::spawn(async { 1 });
//     assert_eq!(h.await.unwrap(), 1);
// }

use std::thread;
let name = String::from("w");
thread::spawn(move || name.len()).join().unwrap()  // 1

use std::sync::RwLock;
let l = RwLock::new(1);
*l.read().unwrap()  // 1

use std::sync::atomic::{AtomicUsize, Ordering};
let n = AtomicUsize::new(0);
n.fetch_add(1, Ordering::SeqCst);
n.load(Ordering::SeqCst)  // 1

// tokio::select! { r = rx.recv() => ..., t = sleep => ... }

use std::thread;
let h = thread::spawn(|| "done");
h.join().unwrap()  // "done"

// thread::park(); other.thread().unpark();

use std::thread;
let v = vec![1, 2];
thread::scope(|s| {
    s.spawn(|| v.len());
});
v.len()  // 2

// while let Some(item) = stream.next().await { ... }

// futures::executor::block_on(async { 1 }) == 1
// or tokio Runtime::block_on