Smart Pointers & Concurrency

#[derive(Debug)]
enum List {
    Cons(i32, Box<List>),
    Nil,
}

use List::{Cons, Nil};

fn sum(list: &List) -> i32 {
    match list {
        Cons(v, rest) => v + sum(rest),
        Nil => 0,
    }
}

fn main() {
    let b = Box::new(41);          // an i32 on the heap
    println!("{}", *b + 1);        // * reaches the value inside

    let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
    println!("{:?}", list);
    println!("sum = {}", sum(&list));
    println!("box size = {} bytes", std::mem::size_of::<Box<List>>());
}

use std::ops::Deref;

struct Meters(f64);

struct Wrapper<T> {
    inner: T,
}

impl<T> Deref for Wrapper<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.inner
    }
}

fn shout(s: &str) {
    println!("{}!", s.to_uppercase());
}

fn main() {
    let w = Wrapper { inner: String::from("hello") };
    println!("{}", w.len());      // String::len through Deref
    shout(&w);                    // &Wrapper<String> -> &String -> &str
    let m = Wrapper { inner: Meters(2.5) };
    println!("{}", m.0);
}

struct Conn {
    id: u32,
}

impl Drop for Conn {
    fn drop(&mut self) {
        println!("closing conn {}", self.id);
    }
}

fn main() {
    let pool = vec![Conn { id: 1 }, Conn { id: 2 }];
    let _ = Conn { id: 9 };          // bound to nothing: dropped right away
    let _kept = Conn { id: 3 };      // a real binding: lives to the end
    println!("pool has {}", pool.len());
    println!("main ends");
}

use std::rc::Rc;

#[derive(Debug)]
struct Config {
    name: String,
}

fn main() {
    let cfg = Rc::new(Config { name: String::from("prod") });
    println!("count after new = {}", Rc::strong_count(&cfg));

    let api = Rc::clone(&cfg);            // cheap: bumps a counter
    {
        let worker = Rc::clone(&cfg);
        println!("count inside = {}", Rc::strong_count(&cfg));
        println!("worker sees {}", worker.name);
    }
    println!("count after block = {}", Rc::strong_count(&cfg));
    println!("same allocation: {}", Rc::ptr_eq(&cfg, &api));
    drop(cfg);
    println!("api still has {:?}, count = {}", api, Rc::strong_count(&api));
}

use std::cell::{Cell, RefCell};

struct Counter {
    hits: Cell<u32>,
    log: RefCell<Vec<String>>,
}

impl Counter {
    fn record(&self, msg: &str) {        // &self, yet it changes state
        self.hits.set(self.hits.get() + 1);
        self.log.borrow_mut().push(msg.to_string());
    }
}

fn main() {
    let c = Counter { hits: Cell::new(0), log: RefCell::new(Vec::new()) };
    c.record("login");
    c.record("view");
    println!("hits = {}", c.hits.get());
    println!("log = {:?}", c.log.borrow());

    let r1 = c.log.borrow();
    let r2 = c.log.borrow();            // many readers: fine
    println!("{} {}", r1.len(), r2[0]);
    drop(r1);
    drop(r2);
    println!("{}", c.log.try_borrow_mut().is_ok());
}

use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
struct Account {
    owner: String,
    balance: i64,
}

fn main() {
    let shared = Rc::new(RefCell::new(Account { owner: String::from("ana"), balance: 100 }));

    let mobile = Rc::clone(&shared);
    let web = Rc::clone(&shared);

    mobile.borrow_mut().balance -= 30;
    web.borrow_mut().balance += 5;

    let acct = shared.borrow();
    println!("{} has {}", acct.owner, acct.balance);
    println!("owners = {}", Rc::strong_count(&shared));
}

use std::cell::RefCell;
use std::rc::{Rc, Weak};

struct Node {
    name: String,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let leaf = Rc::new(Node {
        name: String::from("leaf"),
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });
    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade().map(|p| p.name.clone()));

    {
        let branch = Rc::new(Node {
            name: String::from("branch"),
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![Rc::clone(&leaf)]),
        });
        *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

        println!("leaf parent = {:?}", leaf.parent.borrow().upgrade().map(|p| p.name.clone()));
        println!("branch strong = {}, weak = {}", Rc::strong_count(&branch), Rc::weak_count(&branch));
        println!("branch has {} child", branch.children.borrow().len());
    }

    // branch is gone: the Weak did not keep it alive
    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade().map(|p| p.name.clone()));
    println!("leaf strong = {}", Rc::strong_count(&leaf));
}

use std::thread;

fn main() {
    let mut handles = Vec::new();
    for id in 1..=3 {
        handles.push(thread::spawn(move || {
            let sum: u64 = (1..=id * 1000).sum();
            (id, sum)                       // the thread's return value
        }));
    }

    // join waits for each thread and hands back its result, in spawn order
    for h in handles {
        let (id, sum) = h.join().unwrap();
        println!("thread {} summed to {}", id, sum);
    }
    println!("all done");
}

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    let producer = thread::spawn(move || {
        for job in ["parse", "validate", "store"] {
            tx.send(job.to_string()).unwrap();
        }
        // tx is dropped here, which closes the channel
    });

    for msg in rx {                      // ends when every sender is gone
        println!("got {}", msg);
    }
    producer.join().unwrap();
}

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    for worker in 1..=3 {
        let tx = tx.clone();             // one sender per thread
        thread::spawn(move || {
            for n in 0..2 {
                tx.send(format!("w{}-{}", worker, n)).unwrap();
            }
        });
    }
    drop(tx);                            // drop the original, or rx waits forever

    let mut results: Vec<String> = rx.iter().collect();
    results.sort();                      // arrival order varies; sort before printing
    println!("{} messages", results.len());
    println!("{:?}", results);
}

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let total = Arc::new(Mutex::new(0));
    let mut handles = Vec::new();

    for i in 1..=4 {
        let total = Arc::clone(&total);
        handles.push(thread::spawn(move || {
            for _ in 0..1000 {
                let mut guard = total.lock().unwrap();
                *guard += i;
            }                            // guard dropped: lock released
        }));
    }
    for h in handles {
        h.join().unwrap();
    }

    println!("total = {}", *total.lock().unwrap());
    println!("owners left = {}", Arc::strong_count(&total));
}

use std::sync::{Arc, RwLock};
use std::thread;

fn main() {
    let settings = Arc::new(RwLock::new(vec![String::from("dark-mode")]));

    let readers: Vec<_> = (0..3)
        .map(|_| {
            let s = Arc::clone(&settings);
            thread::spawn(move || s.read().unwrap().len())
        })
        .collect();
    let counts: Vec<usize> = readers.into_iter().map(|h| h.join().unwrap()).collect();
    println!("{:?}", counts);

    settings.write().unwrap().push(String::from("beta"));
    println!("{:?}", settings.read().unwrap());
}

use std::thread;

fn main() {
    let words = vec!["alpha", "beta", "gamma", "delta"];
    let mut lengths = vec![0; words.len()];

    thread::scope(|s| {
        for (word, slot) in words.iter().zip(lengths.iter_mut()) {
            s.spawn(move || {
                *slot = word.len();      // writes into main's Vec, no Arc needed
            });
        }
    }); // every scoped thread is joined here

    println!("{:?}", words);             // still usable: only borrowed
    println!("{:?}", lengths);
}