path: root/rust-book/concurrency/src/main.rs

use std::sync::Arc;
use std::rc::Rc;
use std::sync::Mutex;
use std::thread;
use std::sync::mpsc;
use std::time::Duration;

fn main() {
//    let handle = thread::spawn(|| {
//        for i in 1..10 {
//            println!("spawned: {}", i);
//            thread::sleep(Duration::from_millis(1));
//        }
//    });
//
//    for i in 1..5 {
//        println!("main: {}", i);
//        thread::sleep(Duration::from_millis(1));
//    }
//
//    handle.join().unwrap();



//    let v = vec![1, 2, 3];
//
//    let handle = thread::spawn(move || {
//        println!("Here's a vector: {:?}", v);
//    });
//
//    drop(v);
//    handle.join().unwrap();



//    let (tx, rx) = mpsc::channel();
//
//    thread::spawn(move || {
//        let val = String::from("hi");
//        tx.send(val).unwrap();
//        dbg!(val);
//    });
//
//    let received = rx.recv().unwrap();
//    dbg!(received);



//    let (tx, rx) = mpsc::channel();
//
//    thread::spawn(move || {
//        let vals = vec![
//            String::from("the"),
//            String::from("walking"),
//            String::from("thread"),
//        ];
//
//        for val in vals {
//            tx.send(val).unwrap();
//            thread::sleep(Duration::from_secs(1));
//        }
//    });
//
//    for received in rx {
//        println!("got {}", received);
//    }



//    let (tx, rx) = mpsc::channel();
//
//    let tx1 = mpsc::Sender::clone(&tx);
//    thread::spawn(move || {
//        let vals = vec![
//            String::from("the"),
//            String::from("walking"),
//            String::from("thread"),
//        ];
//
//        for val in vals {
//            tx1.send(val).unwrap();
//            thread::sleep(Duration::from_secs(1));
//        }
//    });
//
//    thread::spawn(move || {
//        let vals = vec![
//            String::from("welcome"),
//            String::from("to"),
//            String::from("woodberry"),
//            String::from("!"),
//        ];
//
//        for val in vals {
//            tx.send(val).unwrap();
//            thread::sleep(Duration::from_secs(1));
//        }
//    });
//
//    for received in rx {
//        dbg!(received);
//    }



//    let m = Mutex::new(5);
//
//    {
//        let mut num = m.lock().unwrap();
//        *num = 6;
//    }
//
//    println!("m = {:?}", m);



    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }
    
    dbg!(*counter.lock().unwrap());

    println!("Done.");
}