rust编程-线程：无畏并发

目前了解到，Rust实现线程间通信依靠的是消息传递和共享内存两种方式，消息传递必须使用move/clone，而共享内存使用mutex性能有开销。Rust也无法避免死锁和循环引用（ 类似于Rc，Arc也不能幸免，但可以使用Atomic Weak来避免循环引用）。

use std::thread;
use std::time::Duration;
use std::sync::mpsc;
use std::sync::{Arc,Mutex};

fn main(){
//线程
    println!("====线程实例输出====");
    let t = thread::spawn(|| {
        for i in 1..=6{
            println!("线程：{}",i);
            thread::sleep(Duration::from_millis(1));
        }
    });
    for i in 1..3{
        println!("主线程：{}",i);
        thread::sleep(Duration::from_millis(1));
    }
    t.join().unwrap();
    
//消息传递：必须通过 移动move/克隆clone 才能传送到另一个线程
    println!("====消息传递实例输出====");
    let (tx1,rx) = mpsc::channel();
    let tx2 = mpsc::Sender::clone(&tx1);
    thread::spawn(move|| {
        tx1.send(String::from("线程1发送端")).unwrap();
    });
    thread::spawn(move|| {
        tx2.send(String::from("线程2发送端")).unwrap();
    });
    for recvd in rx{ //tx1和tx2都不需要join，因为接收端会阻塞直到收到消息
        println!("接收端:{}",recvd);
    }
    
//共享状态：通过Arc和Mutex实现多所有权
//不使用Rc是因为它没有实现Send trait，不能在线程间共享。原子引用计数模型Arc是线程安全的。
//不使用RefCell是因为它没有Send trait和Sync trait，不能在线程间共享。Mutex是线程安全的。
    println!("====共享状态实例输出====");
    let counter = Arc::new(Mutex::new(0));//一个可变的引用计数，初始化为0
    let mut threads = vec![];
    for _ in 0..5{
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num_guard = (*counter).lock().unwrap();
            *num_guard += 1;
        });
        threads.push(handle);
    }
    for thread in threads {
        thread.join().unwrap();
    }
    println!("Result: {}", *counter.lock().unwrap());//lock()返回的是Ok或Error。通过调用unwrap()导出，如果是Ok，unwrap()会返回其内部对象（这里是MutexGuard），如果是Error则会 panic。
}   
    

输出结果为：

====线程实例输出====
主线程：1
线程：1
主线程：2
线程：2
线程：3
线程：4
线程：5
线程：6
====消息传递实例输出====
接收端:线程1发送端
接收端:线程2发送端
====共享状态实例输出====
Result: 5

参考链接：Rust无畏并发