《Rust权威指南》第16章_无畏并发_草稿

• 使用线程同时运行代码
  • 使用spawn创建新线程
  • 使用join句柄等待所有线程结束
  • 在线程中使用move闭包
• 使用消息传递在线程间转移数据
  • 通道和所有权转移
  • 发送多个值并观察接收者的等待过程
  • 通过克隆发送者创建多个生产者
• 共享状态的并发
  • 互斥体一次只允许一个线程访问数据
    • Mutex的接口
    • 在多个线程间共享Mutex
    • 多线程与多重所有权
    • 原子引用计数Arc
  • RefCell/Rc和Mutex/Arc之间的相似性
• 使用Sync trait和Send trait对并发进行拓展
  • 允许线程间转移所有权的Send trait
  • 允许多线程同时访问的Sync trait
  • 手动实现Send和Sync是不安全的

message_passing

use std::thread;
use std::sync::mpsc;
use std::time::Duration;

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

    let tx1 = mpsc::Sender::clone(&tx);

    thread::spawn(move || {
        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            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("more"),
           String::from("message"),
           String::from("for"),
           String::from("you"),
       ];

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });

    for received in rx {
        println!("Got: {}", received);
    }
}

mutex

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

fn main() {
    /*
    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();
    }

    println!("Result: {}", *counter.lock().unwrap());
}